ngx-bootstrap 3.0.1 → 3.1.4

package/chronos/esm5/test/chain.js

@@ -0,0 +1,1506 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { add, subtract } from '../index';
+import { getDate, getFullYear, getHours, getMilliseconds, getMinutes, getMonth, getSeconds } from '../utils/date-getters';
+import { setDate, setFullYear, setHours, setMilliseconds, setMinutes, setMonth, setSeconds } from '../utils/date-setters';
+import { cloneDate } from '../create/clone';
+import { isArray, isBoolean, isDate, isDateValid, isFunction, isNumber, isObject, isString, isUndefined } from '../utils/type-checks';
+import { formatDate } from '../format';
+import { ISO_8601, RFC_2822 } from '../create/from-string-and-format';
+import { getDateOffset, getUTCOffset, hasAlignedHourOffset, isDaylightSavingTime, setOffsetToParsedOffset, setUTCOffset } from '../units/offset';
+import { isLeapYear, parseTwoDigitYear } from '../units/year';
+import { isAfter, isBefore, isBetween, isSame, isSameOrAfter, isSameOrBefore } from '../utils/date-compare';
+import { daysInMonth } from '../units/month';
+import { getDayOfWeek, getISODayOfWeek, getLocaleDayOfWeek, parseWeekday, setDayOfWeek, setISODayOfWeek, setLocaleDayOfWeek } from '../units/day-of-week';
+import { getISOWeek, getWeek, setISOWeek, setWeek } from '../units/week';
+import { getISOWeeksInYear, getISOWeekYear, getSetISOWeekYear, getSetWeekYear, getWeeksInYear, getWeekYear } from '../units/week-year';
+import { endOf, startOf } from '../utils/start-end-of';
+import { getQuarter, setQuarter } from '../units/quarter';
+import { getDayOfYear, setDayOfYear } from '../units/day-of-year';
+import { getZoneAbbr, getZoneName } from '../units/timezone';
+import { diff } from '../moment/diff';
+import { calendar } from '../moment/calendar';
+import { defineLocale, getLocale, getSetGlobalLocale, listLocales } from '../locale/locales';
+import { max, min } from '../moment/min-max';
+import { isDuration } from '../duration/constructor';
+import { createLocalOrUTC } from '../create/from-anything';
+import { createDuration } from '../duration/create';
+export var /** @type {?} */ moment = (/** @type {?} */ (_moment));
+/**
+ * @record
+ */
+export function MomentFn() { }
+function MomentFn_tsickle_Closure_declarations() {
+    /* TODO: handle strange member:
+    (input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean, isUTC?: boolean): Khronos;
+    */
+    /** @type {?} */
+    MomentFn.prototype.ISO_8601;
+    /** @type {?} */
+    MomentFn.prototype.RFC_2822;
+    /** @type {?} */
+    MomentFn.prototype.utc;
+    /** @type {?} */
+    MomentFn.prototype.parseZone;
+    /** @type {?} */
+    MomentFn.prototype.unix;
+    /** @type {?} */
+    MomentFn.prototype.locale;
+    /** @type {?} */
+    MomentFn.prototype.duration;
+    /** @type {?} */
+    MomentFn.prototype.defineLocale;
+    /** @type {?} */
+    MomentFn.prototype.parseTwoDigitYear;
+    /** @type {?} */
+    MomentFn.prototype.isDate;
+    /** @type {?} */
+    MomentFn.prototype.months;
+    /** @type {?} */
+    MomentFn.prototype.months;
+    /** @type {?} */
+    MomentFn.prototype.months;
+    /** @type {?} */
+    MomentFn.prototype.months;
+    /** @type {?} */
+    MomentFn.prototype.monthsShort;
+    /** @type {?} */
+    MomentFn.prototype.monthsShort;
+    /** @type {?} */
+    MomentFn.prototype.monthsShort;
+    /** @type {?} */
+    MomentFn.prototype.monthsShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdays;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysShort;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.weekdaysMin;
+    /** @type {?} */
+    MomentFn.prototype.relativeTimeThreshold;
+    /** @type {?} */
+    MomentFn.prototype.relativeTimeThreshold;
+    /** @type {?} */
+    MomentFn.prototype.min;
+    /** @type {?} */
+    MomentFn.prototype.max;
+    /** @type {?} */
+    MomentFn.prototype.localeData;
+    /** @type {?} */
+    MomentFn.prototype.updateLocale;
+    /** @type {?} */
+    MomentFn.prototype.calendarFormat;
+    /** @type {?} */
+    MomentFn.prototype.calendarFormat;
+    /** @type {?} */
+    MomentFn.prototype.invalid;
+    /** @type {?} */
+    MomentFn.prototype.locales;
+    /** @type {?} */
+    MomentFn.prototype.updateOffset;
+}
+/**
+ * @param {?=} input
+ * @param {?=} format
+ * @param {?=} localeKey
+ * @param {?=} strict
+ * @param {?=} isUTC
+ * @return {?}
+ */
+function _moment(input, format, localeKey, strict, isUTC) {
+    if (input instanceof Khronos) {
+        var /** @type {?} */ _date = input.clone();
+        return isUTC ? _date.utc() : _date;
+    }
+    if (isBoolean(localeKey)) {
+        return new Khronos(input, format, null, localeKey, isUTC);
+    }
+    return new Khronos(input, format, localeKey, strict, isUTC);
+}
+moment.utc = function (input, format, localeKey, strict) {
+    return _moment(input, format, localeKey, strict, true);
+};
+moment.parseZone = function (input, format, localeKey, strict) {
+    return _moment(input, format, localeKey, strict, true).parseZone();
+};
+moment.locale = getSetGlobalLocale;
+moment.localeData = function (key) {
+    if (key instanceof Khronos) {
+        return key.localeData();
+    }
+    return getLocale(key);
+};
+// moment.utc = createUTC;
+moment.unix = function (inp) { return new Khronos(inp * 1000); };
+moment.ISO_8601 = ISO_8601;
+moment.RFC_2822 = RFC_2822;
+moment.defineLocale = defineLocale;
+moment.parseTwoDigitYear = parseTwoDigitYear;
+moment.isDate = isDate;
+moment.invalid = function _invalid() {
+    return new Khronos(new Date(NaN));
+};
+// duration(inp?: Duration | DateInput | Khronos, unit?: MomentUnitOfTime): Duration;
+moment.duration = function (input, unit) {
+    var /** @type {?} */ _unit = mapUnitOfTime(unit);
+    if (isDate(input)) {
+        throw new Error('todo implement');
+    }
+    if (input == null) {
+        return createDuration();
+    }
+    if (isDuration(input)) {
+        return createDuration(input, _unit, { _locale: input._locale });
+    }
+    if (isString(input) || isNumber(input) || isDuration(input) || isObject(input)) {
+        return createDuration(input, _unit);
+    }
+    throw new Error('todo implement');
+};
+moment.min = function _min() {
+    var dates = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        dates[_i] = arguments[_i];
+    }
+    var /** @type {?} */ _firstArg = dates[0];
+    var /** @type {?} */ _dates = (isArray(_firstArg) ? _firstArg : dates)
+        .map(function (date) { return _moment(date); })
+        .map(function (date) { return date.toDate(); });
+    var /** @type {?} */ _date = min.apply(void 0, tslib_1.__spread(_dates));
+    return new Khronos(_date);
+};
+moment.max = function _max() {
+    var dates = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        dates[_i] = arguments[_i];
+    }
+    var /** @type {?} */ _firstArg = dates[0];
+    var /** @type {?} */ _dates = (isArray(_firstArg) ? _firstArg : dates)
+        .map(function (date) { return _moment(date); })
+        .map(function (date) { return date.toDate(); });
+    var /** @type {?} */ _date = max.apply(void 0, tslib_1.__spread(_dates));
+    return new Khronos(_date);
+};
+moment.locales = function () {
+    return listLocales();
+};
+/**
+ * @record
+ */
+export function MomentInputObject() { }
+function MomentInputObject_tsickle_Closure_declarations() {
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.years;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.year;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.y;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.months;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.month;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.M;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.days;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.day;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.d;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.dates;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.date;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.D;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.hours;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.hour;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.h;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.minutes;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.minute;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.m;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.seconds;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.second;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.s;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.milliseconds;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.millisecond;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.ms;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.w;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.week;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.weeks;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.Q;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.quarter;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.quarters;
+    /** @type {?|undefined} */
+    MomentInputObject.prototype.weekYear;
+}
+var /** @type {?} */ _unitsPriority = {
+    year: 1,
+    month: 8,
+    week: 5,
+    isoWeek: 5,
+    day: 11,
+    weekday: 11,
+    isoWeekday: 11,
+    hours: 13,
+    weekYear: 1,
+    isoWeekYear: 1,
+    quarter: 7,
+    date: 9,
+    dayOfYear: 4,
+    minutes: 14,
+    seconds: 15,
+    milliseconds: 16
+};
+// todo: do I need 2 mappers?
+var /** @type {?} */ _timeHashMap = {
+    y: 'year',
+    years: 'year',
+    year: 'year',
+    M: 'month',
+    months: 'month',
+    month: 'month',
+    w: 'week',
+    weeks: 'week',
+    week: 'week',
+    d: 'day',
+    days: 'day',
+    day: 'day',
+    date: 'date',
+    dates: 'date',
+    D: 'date',
+    h: 'hours',
+    hour: 'hours',
+    hours: 'hours',
+    m: 'minutes',
+    minute: 'minutes',
+    minutes: 'minutes',
+    s: 'seconds',
+    second: 'seconds',
+    seconds: 'seconds',
+    ms: 'milliseconds',
+    millisecond: 'milliseconds',
+    milliseconds: 'milliseconds',
+    quarter: 'quarter',
+    quarters: 'quarter',
+    q: 'quarter',
+    Q: 'quarter',
+    isoWeek: 'isoWeek',
+    isoWeeks: 'isoWeek',
+    W: 'isoWeek',
+    weekYear: 'weekYear',
+    weekYears: 'weekYear',
+    gg: 'weekYears',
+    isoWeekYear: 'isoWeekYear',
+    isoWeekYears: 'isoWeekYear',
+    GG: 'isoWeekYear',
+    dayOfYear: 'dayOfYear',
+    dayOfYears: 'dayOfYear',
+    DDD: 'dayOfYear',
+    weekday: 'weekday',
+    weekdays: 'weekday',
+    e: 'weekday',
+    isoWeekday: 'isoWeekday',
+    isoWeekdays: 'isoWeekday',
+    E: 'isoWeekday'
+};
+/**
+ * @param {?} period
+ * @return {?}
+ */
+function mapUnitOfTime(period) {
+    return /** @type {?} */ (_timeHashMap[period]);
+}
+/**
+ * @param {?} obj
+ * @return {?}
+ */
+function mapMomentInputObject(obj) {
+    var /** @type {?} */ _res = {};
+    return Object.keys(obj)
+        .reduce(function (res, key) {
+        res[mapUnitOfTime(key)] = obj[key];
+        return res;
+    }, _res);
+}
+var Khronos = /** @class */ (function () {
+    function Khronos(input, format, localeKey, strict, isUTC, offset) {
+        if (strict === void 0) { strict = false; }
+        if (isUTC === void 0) { isUTC = false; }
+        this._date = new Date();
+        this._isUTC = false;
+        // locale will be needed to format invalid date message
+        this._locale = getLocale(localeKey);
+        // parse invalid input
+        if (input === '' || input === null || (isNumber(input) && isNaN(input))) {
+            this._date = new Date(NaN);
+            return this;
+        }
+        this._isUTC = isUTC;
+        if (this._isUTC) {
+            this._offset = 0;
+        }
+        if (offset || offset === 0) {
+            this._offset = offset;
+        }
+        this._isStrict = strict;
+        this._format = format;
+        if (!input && input !== 0 && !format) {
+            this._date = new Date();
+            return this;
+        }
+        if (isDate(input)) {
+            this._date = cloneDate(input);
+            return this;
+        }
+        // this._date = parseDate(input, format, localeKey, strict, isUTC);
+        var /** @type {?} */ config = createLocalOrUTC(input, format, localeKey, strict, isUTC);
+        this._date = config._d;
+        this._offset = isNumber(config._offset) ? config._offset : this._offset;
+        this._isUTC = config._isUTC;
+        this._isStrict = config._strict;
+        this._format = config._f;
+        this._tzm = config._tzm;
+    }
+    /**
+     * @return {?}
+     */
+    Khronos.prototype._toConfig = /**
+     * @return {?}
+     */
+    function () {
+        return { _isUTC: this._isUTC, _locale: this._locale, _offset: this._offset, _tzm: this._tzm };
+    };
+    /**
+     * @param {?=} localeKey
+     * @return {?}
+     */
+    Khronos.prototype.locale = /**
+     * @param {?=} localeKey
+     * @return {?}
+     */
+    function (localeKey) {
+        if (isUndefined(localeKey)) {
+            return this._locale._abbr;
+        }
+        if (localeKey instanceof Khronos) {
+            this._locale = localeKey._locale;
+            return this;
+        }
+        var /** @type {?} */ newLocaleData = getLocale(localeKey);
+        if (newLocaleData != null) {
+            this._locale = newLocaleData;
+        }
+        return this;
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.localeData = /**
+     * @return {?}
+     */
+    function () {
+        return this._locale;
+    };
+    // Basic
+    /**
+     * @param {?} val
+     * @param {?=} period
+     * @return {?}
+     */
+    Khronos.prototype.add = /**
+     * @param {?} val
+     * @param {?=} period
+     * @return {?}
+     */
+    function (val, period) {
+        var _this = this;
+        if (isString(val)) {
+            this._date = add(this._date, parseInt(val, 10), mapUnitOfTime(period));
+        }
+        if (isNumber(val)) {
+            this._date = add(this._date, val, mapUnitOfTime(period));
+        }
+        if (isObject(val)) {
+            var /** @type {?} */ _mapped_1 = mapMomentInputObject(val);
+            Object.keys(_mapped_1)
+                .forEach(function (key) { return add(_this._date, _mapped_1[key], key); });
+        }
+        return this;
+    };
+    // fixme: for some reason here 'null' for time is fine
+    /**
+     * @param {?=} time
+     * @param {?=} formats
+     * @return {?}
+     */
+    Khronos.prototype.calendar = /**
+     * @param {?=} time
+     * @param {?=} formats
+     * @return {?}
+     */
+    function (time, formats) {
+        var /** @type {?} */ _time = time instanceof Khronos ? time : new Khronos(time || new Date());
+        var /** @type {?} */ _offset = (this._offset || 0) - (_time._offset || 0);
+        var /** @type {?} */ _config = Object.assign(this._toConfig(), { _offset: _offset });
+        return calendar(this._date, _time._date, formats, this._locale, _config);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.clone = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ localeKey = this._locale && this._locale._abbr || 'en';
+        // return new Khronos(cloneDate(this._date), this._format, localeKey, this._isStrict, this._isUTC);
+        // fails if isUTC and offset
+        // return new Khronos(new Date(this.valueOf()),
+        return new Khronos(this._date, this._format, localeKey, this._isStrict, this._isUTC, this._offset);
+    };
+    /**
+     * @param {?} b
+     * @param {?=} unitOfTime
+     * @param {?=} precise
+     * @return {?}
+     */
+    Khronos.prototype.diff = /**
+     * @param {?} b
+     * @param {?=} unitOfTime
+     * @param {?=} precise
+     * @return {?}
+     */
+    function (b, unitOfTime, precise) {
+        var /** @type {?} */ unit = mapUnitOfTime(unitOfTime);
+        var /** @type {?} */ _b = b instanceof Khronos ? b : new Khronos(b);
+        // const zoneDelta = (_b.utcOffset() - this.utcOffset());
+        // const config = Object.assign(this._toConfig(), {
+        //   _offset: 0,
+        //   _isUTC: true,
+        //   _zoneDelta: zoneDelta
+        // });
+        // return diff(new Date(this.valueOf()), new Date(_b.valueOf()), unit, precise, config);
+        return diff(this._date, _b.toDate(), unit, precise, this._toConfig());
+    };
+    /**
+     * @param {?=} period
+     * @return {?}
+     */
+    Khronos.prototype.endOf = /**
+     * @param {?=} period
+     * @return {?}
+     */
+    function (period) {
+        var /** @type {?} */ _per = mapUnitOfTime(period);
+        this._date = endOf(this._date, _per, this._isUTC);
+        return this;
+    };
+    /**
+     * @param {?=} format
+     * @return {?}
+     */
+    Khronos.prototype.format = /**
+     * @param {?=} format
+     * @return {?}
+     */
+    function (format) {
+        return formatDate(this._date, format, this._locale && this._locale._abbr, this._isUTC, this._offset);
+    };
+    // todo: implement
+    /**
+     * @param {?=} time
+     * @param {?=} withoutSuffix
+     * @return {?}
+     */
+    Khronos.prototype.from = /**
+     * @param {?=} time
+     * @param {?=} withoutSuffix
+     * @return {?}
+     */
+    function (time, withoutSuffix) {
+        var /** @type {?} */ _time = _moment(time);
+        if (this.isValid() && _time.isValid()) {
+            return createDuration({ to: this.toDate(), from: _time.toDate() })
+                .locale(this.locale())
+                .humanize(!withoutSuffix);
+        }
+        return this.localeData().invalidDate;
+    };
+    /**
+     * @param {?=} withoutSuffix
+     * @return {?}
+     */
+    Khronos.prototype.fromNow = /**
+     * @param {?=} withoutSuffix
+     * @return {?}
+     */
+    function (withoutSuffix) {
+        return this.from(new Date(), withoutSuffix);
+    };
+    /**
+     * @param {?} inp
+     * @param {?=} suffix
+     * @return {?}
+     */
+    Khronos.prototype.to = /**
+     * @param {?} inp
+     * @param {?=} suffix
+     * @return {?}
+     */
+    function (inp, suffix) {
+        throw new Error("TODO: Implement");
+    };
+    /**
+     * @param {?=} withoutPrefix
+     * @return {?}
+     */
+    Khronos.prototype.toNow = /**
+     * @param {?=} withoutPrefix
+     * @return {?}
+     */
+    function (withoutPrefix) {
+        throw new Error("TODO: Implement");
+    };
+    /**
+     * @param {?} val
+     * @param {?=} period
+     * @return {?}
+     */
+    Khronos.prototype.subtract = /**
+     * @param {?} val
+     * @param {?=} period
+     * @return {?}
+     */
+    function (val, period) {
+        var _this = this;
+        if (isString(val)) {
+            this._date = subtract(this._date, parseInt(val, 10), mapUnitOfTime(period));
+            return this;
+        }
+        if (isNumber(val)) {
+            this._date = subtract(this._date, val, mapUnitOfTime(period));
+        }
+        if (isObject(val)) {
+            var /** @type {?} */ _mapped_2 = mapMomentInputObject(val);
+            Object.keys(_mapped_2)
+                .forEach(function (key) { return subtract(_this._date, _mapped_2[key], key); });
+        }
+        return this;
+    };
+    /**
+     * @param {?} period
+     * @return {?}
+     */
+    Khronos.prototype.get = /**
+     * @param {?} period
+     * @return {?}
+     */
+    function (period) {
+        if (period === 'dayOfYear') {
+            return this.dayOfYear();
+        }
+        var /** @type {?} */ unit = mapUnitOfTime(period);
+        switch (unit) {
+            case 'year':
+                return this.year();
+            case 'month':
+                return this.month();
+            // | 'week'
+            case 'date':
+                return this.date();
+            case 'day':
+                return this.day();
+            case 'hours':
+                return this.hours();
+            case 'minutes':
+                return this.minutes();
+            case 'seconds':
+                return this.seconds();
+            case 'milliseconds':
+                return this.milliseconds();
+            case 'week':
+                return this.week();
+            case 'isoWeek':
+                return this.isoWeek();
+            case 'weekYear':
+                return this.weekYear();
+            case 'isoWeekYear':
+                return this.isoWeekYear();
+            case 'weekday':
+                return this.weekday();
+            case 'isoWeekday':
+                return this.isoWeekday();
+            case 'quarter':
+                return this.quarter();
+            default:
+                throw new Error("Unknown moment.get('" + period + "')");
+        }
+    };
+    /**
+     * @param {?} period
+     * @param {?=} input
+     * @return {?}
+     */
+    Khronos.prototype.set = /**
+     * @param {?} period
+     * @param {?=} input
+     * @return {?}
+     */
+    function (period, input) {
+        var _this = this;
+        if (isString(period)) {
+            var /** @type {?} */ unit = mapUnitOfTime(period);
+            switch (unit) {
+                case 'year':
+                    return this.year(input);
+                case 'month':
+                    return this.month(input);
+                // | 'week'
+                case 'day':
+                    return this.day(input);
+                case 'date':
+                    return this.date(input);
+                case 'hours':
+                    return this.hours(input);
+                case 'minutes':
+                    return this.minutes(input);
+                case 'seconds':
+                    return this.seconds(input);
+                case 'milliseconds':
+                    return this.milliseconds(input);
+                case 'week':
+                    return this.week(input);
+                case 'isoWeek':
+                    return this.isoWeek(input);
+                case 'weekYear':
+                    return this.weekYear(input);
+                case 'isoWeekYear':
+                    return this.isoWeekYear(input);
+                case 'weekday':
+                    return this.weekday(input);
+                case 'isoWeekday':
+                    return this.isoWeekday(input);
+                case 'quarter':
+                    return this.quarter(input);
+                default:
+                    throw new Error("Unknown moment.get('" + period + "')");
+            }
+        }
+        if (isObject(period)) {
+            var /** @type {?} */ _mapped_3 = mapMomentInputObject(period);
+            Object.keys(_mapped_3)
+                .sort(function (a, b) {
+                return _unitsPriority[a] - _unitsPriority[b];
+            })
+                .forEach(function (key) { return _this.set(key, _mapped_3[key]); });
+        }
+        return this;
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.toString = /**
+     * @return {?}
+     */
+    function () {
+        return this.format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.toISOString = /**
+     * @return {?}
+     */
+    function () {
+        if (!this.isValid()) {
+            return null;
+        }
+        if (getFullYear(this._date, true) < 0 || getFullYear(this._date, true) > 9999) {
+            return this.format('YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+        }
+        if (isFunction(Date.prototype.toISOString)) {
+            // native implementation is ~50x faster, use it when we can
+            return this.toDate().toISOString();
+        }
+        return this.format('YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.inspect = /**
+     * @return {?}
+     */
+    function () {
+        throw new Error('TODO: implement');
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.toJSON = /**
+     * @return {?}
+     */
+    function () {
+        return this.toISOString();
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.toDate = /**
+     * @return {?}
+     */
+    function () {
+        return new Date(this.valueOf());
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.toObject = /**
+     * @return {?}
+     */
+    function () {
+        return {
+            // years: getFullYear(this._date, this._isUTC),
+            // months: getMonth(this._date, this._isUTC),
+            year: getFullYear(this._date, this._isUTC),
+            month: getMonth(this._date, this._isUTC),
+            date: getDate(this._date, this._isUTC),
+            hours: getHours(this._date, this._isUTC),
+            minutes: getMinutes(this._date, this._isUTC),
+            seconds: getSeconds(this._date, this._isUTC),
+            milliseconds: getMilliseconds(this._date, this._isUTC)
+        };
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.toArray = /**
+     * @return {?}
+     */
+    function () {
+        return [this.year(), this.month(), this.date(), this.hour(), this.minute(), this.second(), this.millisecond()];
+    };
+    // Dates boolean algebra
+    /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    Khronos.prototype.isAfter = /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    function (date, unit) {
+        var /** @type {?} */ _unit = unit ? mapUnitOfTime(unit) : void 0;
+        return isAfter(this._date, date.toDate(), _unit);
+    };
+    /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    Khronos.prototype.isBefore = /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    function (date, unit) {
+        var /** @type {?} */ _unit = unit ? mapUnitOfTime(unit) : void 0;
+        return isBefore(this.toDate(), date.toDate(), _unit);
+    };
+    /**
+     * @param {?} from
+     * @param {?} to
+     * @param {?=} unit
+     * @param {?=} inclusivity
+     * @return {?}
+     */
+    Khronos.prototype.isBetween = /**
+     * @param {?} from
+     * @param {?} to
+     * @param {?=} unit
+     * @param {?=} inclusivity
+     * @return {?}
+     */
+    function (from, to, unit, inclusivity) {
+        var /** @type {?} */ _unit = unit ? mapUnitOfTime(unit) : void 0;
+        return isBetween(this.toDate(), from.toDate(), to.toDate(), _unit, inclusivity);
+    };
+    /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    Khronos.prototype.isSame = /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    function (date, unit) {
+        var /** @type {?} */ _unit = unit ? mapUnitOfTime(unit) : void 0;
+        return isSame(this._date, date.toDate(), _unit);
+    };
+    /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    Khronos.prototype.isSameOrAfter = /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    function (date, unit) {
+        var /** @type {?} */ _unit = unit ? mapUnitOfTime(unit) : void 0;
+        return isSameOrAfter(this._date, date.toDate(), _unit);
+    };
+    /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    Khronos.prototype.isSameOrBefore = /**
+     * @param {?} date
+     * @param {?=} unit
+     * @return {?}
+     */
+    function (date, unit) {
+        var /** @type {?} */ _unit = unit ? mapUnitOfTime(unit) : void 0;
+        return isSameOrBefore(this._date, date.toDate(), _unit);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isValid = /**
+     * @return {?}
+     */
+    function () {
+        return isDateValid(this._date);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.valueOf = /**
+     * @return {?}
+     */
+    function () {
+        return this._date.valueOf() - ((this._offset || 0) * 60000);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.unix = /**
+     * @return {?}
+     */
+    function () {
+        // return getUnixTime(this._date);
+        return Math.floor(this.valueOf() / 1000);
+    };
+    /**
+     * @param {?=} b
+     * @param {?=} keepLocalTime
+     * @return {?}
+     */
+    Khronos.prototype.utcOffset = /**
+     * @param {?=} b
+     * @param {?=} keepLocalTime
+     * @return {?}
+     */
+    function (b, keepLocalTime) {
+        var /** @type {?} */ _config = this._toConfig();
+        if (!b && b !== 0) {
+            return getUTCOffset(this._date, _config);
+        }
+        this._date = setUTCOffset(this._date, b, keepLocalTime, false, _config);
+        this._offset = _config._offset;
+        this._isUTC = _config._isUTC;
+        return this;
+    };
+    /**
+     * @param {?=} keepLocalTime
+     * @return {?}
+     */
+    Khronos.prototype.utc = /**
+     * @param {?=} keepLocalTime
+     * @return {?}
+     */
+    function (keepLocalTime) {
+        return this.utcOffset(0, keepLocalTime);
+    };
+    /**
+     * @param {?=} keepLocalTime
+     * @return {?}
+     */
+    Khronos.prototype.local = /**
+     * @param {?=} keepLocalTime
+     * @return {?}
+     */
+    function (keepLocalTime) {
+        if (this._isUTC) {
+            this.utcOffset(0, keepLocalTime);
+            this._isUTC = false;
+            if (keepLocalTime) {
+                this.subtract(getDateOffset(this._date), 'm');
+            }
+        }
+        return this;
+    };
+    /**
+     * @param {?=} input
+     * @return {?}
+     */
+    Khronos.prototype.parseZone = /**
+     * @param {?=} input
+     * @return {?}
+     */
+    function (input) {
+        var /** @type {?} */ _config = this._toConfig();
+        this._date = setOffsetToParsedOffset(this._date, input, _config);
+        this._offset = _config._offset;
+        this._isUTC = _config._isUTC;
+        return this;
+    };
+    /**
+     * @param {?=} input
+     * @return {?}
+     */
+    Khronos.prototype.hasAlignedHourOffset = /**
+     * @param {?=} input
+     * @return {?}
+     */
+    function (input) {
+        return hasAlignedHourOffset(this._date, input ? input._date : void 0);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isDST = /**
+     * @return {?}
+     */
+    function () {
+        return isDaylightSavingTime(this._date);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isLocal = /**
+     * @return {?}
+     */
+    function () {
+        return !this._isUTC;
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isUtcOffset = /**
+     * @return {?}
+     */
+    function () {
+        return this._isUTC;
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isUTC = /**
+     * @return {?}
+     */
+    function () {
+        return this.isUtc();
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isUtc = /**
+     * @return {?}
+     */
+    function () {
+        return this._isUTC && this._offset === 0;
+    };
+    // Timezone
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.zoneAbbr = /**
+     * @return {?}
+     */
+    function () {
+        return getZoneAbbr(this._isUTC);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.zoneName = /**
+     * @return {?}
+     */
+    function () {
+        return getZoneName(this._isUTC);
+    };
+    /**
+     * @param {?=} year
+     * @return {?}
+     */
+    Khronos.prototype.year = /**
+     * @param {?=} year
+     * @return {?}
+     */
+    function (year) {
+        if (!year && year !== 0) {
+            return getFullYear(this._date, this._isUTC);
+        }
+        this._date = cloneDate(setFullYear(this._date, year));
+        return this;
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.weekYear = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        if (!val && val !== 0) {
+            return getWeekYear(this._date, this._locale, this.isUTC());
+        }
+        var /** @type {?} */ date = getSetWeekYear(this._date, val, this._locale, this.isUTC());
+        if (isDate(date)) {
+            this._date = date;
+        }
+        return this;
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.isoWeekYear = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        if (!val && val !== 0) {
+            return getISOWeekYear(this._date, this.isUTC());
+        }
+        var /** @type {?} */ date = getSetISOWeekYear(this._date, val, this.isUtc());
+        if (isDate(date)) {
+            this._date = date;
+        }
+        return this;
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isLeapYear = /**
+     * @return {?}
+     */
+    function () {
+        return isLeapYear(getFullYear(this.toDate(), this.isUTC()));
+    };
+    /**
+     * @param {?=} month
+     * @return {?}
+     */
+    Khronos.prototype.month = /**
+     * @param {?=} month
+     * @return {?}
+     */
+    function (month) {
+        if (!month && month !== 0) {
+            return getMonth(this._date, this._isUTC);
+        }
+        var /** @type {?} */ _month = month;
+        if (isString(month)) {
+            var /** @type {?} */ locale = this._locale || getLocale();
+            _month = locale.monthsParse(month);
+        }
+        if (isNumber(_month)) {
+            this._date = cloneDate(setMonth(this._date, _month, this._isUTC));
+        }
+        return this;
+    };
+    /**
+     * @param {?=} hours
+     * @return {?}
+     */
+    Khronos.prototype.hour = /**
+     * @param {?=} hours
+     * @return {?}
+     */
+    function (hours) {
+        return this.hours(hours);
+    };
+    /**
+     * @param {?=} hours
+     * @return {?}
+     */
+    Khronos.prototype.hours = /**
+     * @param {?=} hours
+     * @return {?}
+     */
+    function (hours) {
+        if (!hours && hours !== 0) {
+            return getHours(this._date, this._isUTC);
+        }
+        this._date = cloneDate(setHours(this._date, hours, this._isUTC));
+        return this;
+    };
+    /**
+     * @param {?=} minutes
+     * @return {?}
+     */
+    Khronos.prototype.minute = /**
+     * @param {?=} minutes
+     * @return {?}
+     */
+    function (minutes) {
+        return this.minutes(minutes);
+    };
+    /**
+     * @param {?=} minutes
+     * @return {?}
+     */
+    Khronos.prototype.minutes = /**
+     * @param {?=} minutes
+     * @return {?}
+     */
+    function (minutes) {
+        if (!minutes && minutes !== 0) {
+            return getMinutes(this._date, this._isUTC);
+        }
+        this._date = cloneDate(setMinutes(this._date, minutes, this._isUTC));
+        return this;
+    };
+    /**
+     * @param {?=} seconds
+     * @return {?}
+     */
+    Khronos.prototype.second = /**
+     * @param {?=} seconds
+     * @return {?}
+     */
+    function (seconds) {
+        return this.seconds(seconds);
+    };
+    /**
+     * @param {?=} seconds
+     * @return {?}
+     */
+    Khronos.prototype.seconds = /**
+     * @param {?=} seconds
+     * @return {?}
+     */
+    function (seconds) {
+        if (!seconds && seconds !== 0) {
+            return getSeconds(this._date, this._isUTC);
+        }
+        this._date = cloneDate(setSeconds(this._date, seconds, this._isUTC));
+        return this;
+    };
+    /**
+     * @param {?=} ms
+     * @return {?}
+     */
+    Khronos.prototype.millisecond = /**
+     * @param {?=} ms
+     * @return {?}
+     */
+    function (ms) {
+        return this.milliseconds(ms);
+    };
+    /**
+     * @param {?=} seconds
+     * @return {?}
+     */
+    Khronos.prototype.milliseconds = /**
+     * @param {?=} seconds
+     * @return {?}
+     */
+    function (seconds) {
+        if (!seconds && seconds !== 0) {
+            return getMilliseconds(this._date, this._isUTC);
+        }
+        this._date = cloneDate(setMilliseconds(this._date, seconds, this._isUTC));
+        return this;
+    };
+    /**
+     * @param {?=} date
+     * @return {?}
+     */
+    Khronos.prototype.date = /**
+     * @param {?=} date
+     * @return {?}
+     */
+    function (date) {
+        if (!date && date !== 0) {
+            return getDate(this._date, this._isUTC);
+        }
+        this._date = cloneDate(setDate(this._date, date, this._isUTC));
+        return this;
+    };
+    /**
+     * @param {?=} input
+     * @return {?}
+     */
+    Khronos.prototype.day = /**
+     * @param {?=} input
+     * @return {?}
+     */
+    function (input) {
+        if (!input && input !== 0) {
+            return getDayOfWeek(this._date, this._isUTC);
+        }
+        var /** @type {?} */ _input = input;
+        if (isString(input)) {
+            _input = parseWeekday(input, this._locale);
+        }
+        if (isNumber(_input)) {
+            this._date = setDayOfWeek(this._date, _input, this._locale, this._isUTC);
+        }
+        return this;
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.weekday = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        if (!val && val !== 0) {
+            return getLocaleDayOfWeek(this._date, this._locale, this._isUTC);
+        }
+        this._date = setLocaleDayOfWeek(this._date, val, { locale: this._locale, isUTC: this._isUTC });
+        return this;
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.isoWeekday = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        if (!val && val !== 0) {
+            return getISODayOfWeek(this._date);
+        }
+        this._date = setISODayOfWeek(this._date, val);
+        return this;
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.dayOfYear = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        if (!val && val !== 0) {
+            return getDayOfYear(this._date);
+        }
+        this._date = setDayOfYear(this._date, val);
+        return this;
+    };
+    /**
+     * @param {?=} input
+     * @return {?}
+     */
+    Khronos.prototype.week = /**
+     * @param {?=} input
+     * @return {?}
+     */
+    function (input) {
+        if (!input && input !== 0) {
+            return getWeek(this._date, this._locale);
+        }
+        this._date = setWeek(this._date, input, this._locale);
+        return this;
+    };
+    /**
+     * @param {?=} input
+     * @return {?}
+     */
+    Khronos.prototype.weeks = /**
+     * @param {?=} input
+     * @return {?}
+     */
+    function (input) {
+        return this.week(input);
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.isoWeek = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        if (!val && val !== 0) {
+            return getISOWeek(this._date);
+        }
+        this._date = setISOWeek(this._date, val);
+        return this;
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.isoWeeks = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        return this.isoWeek(val);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.weeksInYear = /**
+     * @return {?}
+     */
+    function () {
+        return getWeeksInYear(this._date, this._isUTC, this._locale);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.isoWeeksInYear = /**
+     * @return {?}
+     */
+    function () {
+        return getISOWeeksInYear(this._date, this._isUTC);
+    };
+    /**
+     * @return {?}
+     */
+    Khronos.prototype.daysInMonth = /**
+     * @return {?}
+     */
+    function () {
+        return daysInMonth(getFullYear(this._date, this._isUTC), getMonth(this._date, this._isUTC));
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.quarter = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        if (!val && val !== 0) {
+            return getQuarter(this._date, this._isUTC);
+        }
+        this._date = setQuarter(this._date, val, this._isUTC);
+        return this;
+    };
+    /**
+     * @param {?=} val
+     * @return {?}
+     */
+    Khronos.prototype.quarters = /**
+     * @param {?=} val
+     * @return {?}
+     */
+    function (val) {
+        return this.quarter(val);
+    };
+    /**
+     * @param {?=} period
+     * @return {?}
+     */
+    Khronos.prototype.startOf = /**
+     * @param {?=} period
+     * @return {?}
+     */
+    function (period) {
+        var /** @type {?} */ _per = mapUnitOfTime(period);
+        this._date = startOf(this._date, _per, this._isUTC);
+        return this;
+    };
+    return Khronos;
+}());
+export { Khronos };
+function Khronos_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Khronos.prototype._date;
+    /** @type {?} */
+    Khronos.prototype._isUTC;
+    /** @type {?} */
+    Khronos.prototype._isStrict;
+    /** @type {?} */
+    Khronos.prototype._locale;
+    /** @type {?} */
+    Khronos.prototype._format;
+    /** @type {?} */
+    Khronos.prototype._offset;
+    /** @type {?} */
+    Khronos.prototype._tzm;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chain.js","sourceRoot":"ng://ngx-bootstrap/chronos/","sources":["test/chain.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:max-line-length max-file-line-count\nimport { add, parseDate, subtract } from '../index';\nimport { DateArray, DateObject, UnitOfTime } from '../types';\nimport {\n  getDate, getFullYear, getHours, getMilliseconds, getMinutes, getMonth, getSeconds,\n  getUnixTime\n} from '../utils/date-getters';\nimport {\n  setDate, setFullYear, setHours, setMilliseconds, setMinutes, setMonth,\n  setSeconds\n} from '../utils/date-setters';\nimport { cloneDate } from '../create/clone';\nimport {\n  isArray,\n  isBoolean, isDate, isDateValid, isFunction, isNumber, isObject, isString,\n  isUndefined\n} from '../utils/type-checks';\nimport { formatDate } from '../format';\nimport { ISO_8601, RFC_2822 } from '../create/from-string-and-format';\nimport { Locale, LocaleData } from '../locale/locale.class';\nimport {\n  getDateOffset,\n  getUTCOffset, hasAlignedHourOffset, isDaylightSavingTime, setOffsetToParsedOffset,\n  setUTCOffset\n} from '../units/offset';\nimport { isLeapYear, parseTwoDigitYear } from '../units/year';\nimport { isAfter, isBefore, isBetween, isSame, isSameOrAfter, isSameOrBefore } from '../utils/date-compare';\nimport { daysInMonth } from '../units/month';\nimport {\n  getDayOfWeek, getISODayOfWeek, getLocaleDayOfWeek, parseWeekday, setDayOfWeek, setISODayOfWeek,\n  setLocaleDayOfWeek\n} from '../units/day-of-week';\nimport { getISOWeek, getWeek, setISOWeek, setWeek } from '../units/week';\nimport {\n  getISOWeeksInYear, getISOWeekYear, getSetISOWeekYear, getSetWeekYear, getWeeksInYear,\n  getWeekYear\n} from '../units/week-year';\nimport { endOf, startOf } from '../utils/start-end-of';\nimport { getQuarter, setQuarter } from '../units/quarter';\nimport { getDayOfYear, setDayOfYear } from '../units/day-of-year';\nimport { getZoneAbbr, getZoneName } from '../units/timezone';\nimport { diff } from '../moment/diff';\nimport { DateParsingConfig } from '../create/parsing.types';\nimport { calendar, CalendarSpec } from '../moment/calendar';\nimport { defineLocale, getLocale, getSetGlobalLocale, listLocales } from '../locale/locales';\nimport { max, min } from '../moment/min-max';\nimport { Duration, isDuration } from '../duration/constructor';\nimport { createLocalOrUTC } from '../create/from-anything';\nimport { createDuration } from '../duration/create';\n\nexport type DateInput = string | number | Date | string[] | DateArray | MomentInputObject;\n\nexport const moment: MomentFn = (_moment as MomentFn);\n\nexport interface MomentFn {\n  (input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean, isUTC?: boolean): Khronos;\n\n  ISO_8601: string;\n  RFC_2822: string;\n\n  utc(input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean): Khronos;\n\n  parseZone(input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean): Khronos;\n\n  unix(num: number): Khronos;\n\n  locale(key?: string | string[], values?: LocaleData): string;\n\n  duration(inp?: Duration | DateInput | Khronos, unit?: MomentUnitOfTime): Duration;\n\n  defineLocale(name: string, config?: LocaleData): Locale;\n\n  parseTwoDigitYear(input: string): number;\n\n  isDate(input?: any): input is Date;\n\n  months(): string[];\n\n  months(index: number): string;\n\n  months(format: string): string[];\n\n  months(format: string, index: number): string;\n\n  monthsShort(): string[];\n\n  monthsShort(index: number): string;\n\n  monthsShort(format: string): string[];\n\n  monthsShort(format: string, index: number): string;\n\n  weekdays(): string[];\n\n  weekdays(index: number): string;\n\n  weekdays(format: string): string[];\n\n  weekdays(format: string, index: number): string;\n\n  weekdays(localeSorted: boolean): string[];\n\n  weekdays(localeSorted: boolean, index: number): string;\n\n  weekdays(localeSorted: boolean, format: string): string[];\n\n  weekdays(localeSorted: boolean, format: string, index: number): string;\n\n  weekdaysShort(): string[];\n\n  weekdaysShort(index: number): string;\n\n  weekdaysShort(format: string): string[];\n\n  weekdaysShort(format: string, index: number): string;\n\n  weekdaysShort(localeSorted: boolean): string[];\n\n  weekdaysShort(localeSorted: boolean, index: number): string;\n\n  weekdaysShort(localeSorted: boolean, format: string): string[];\n\n  weekdaysShort(localeSorted: boolean, format: string, index: number): string;\n\n  weekdaysMin(): string[];\n\n  weekdaysMin(index: number): string;\n\n  weekdaysMin(format: string): string[];\n\n  weekdaysMin(format: string, index: number): string;\n\n  weekdaysMin(localeSorted: boolean): string[];\n\n  weekdaysMin(localeSorted: boolean, index: number): string;\n\n  weekdaysMin(localeSorted: boolean, format: string): string[];\n\n  weekdaysMin(localeSorted: boolean, format: string, index: number): string;\n\n  relativeTimeThreshold(threshold: string): number | boolean;\n\n  relativeTimeThreshold(threshold: string, limit: number): boolean;\n\n  min(...dates: ((DateInput | Khronos)[] | (DateInput | Khronos))[]): Khronos;\n\n  max(...dates: ((DateInput | Khronos)[] | (DateInput | Khronos))[]): Khronos;\n\n  localeData(key?: string | string[] | Khronos): Locale;\n\n  updateLocale(language: string, localeSpec?: LocaleData): Locale;\n\n  calendarFormat(m: Date, now: Date): string;\n\n  // todo: remove this\n  calendarFormat(m: Khronos, now: Khronos): string;\n\n  // todo: implement\n  invalid(): Khronos;\n\n  locales(): string[];\n\n  // todo: implement\n  updateOffset(m: Khronos, keepTime?: boolean): void;\n}\n\nfunction _moment(input?: DateInput | Khronos, format?: string | string[], localeKey?: string | boolean, strict?: boolean, isUTC?: boolean): Khronos {\n  if (input instanceof Khronos) {\n    const _date = input.clone();\n\n    return isUTC ? _date.utc() : _date;\n  }\n\n  if (isBoolean(localeKey)) {\n    return new Khronos(input, format, null, localeKey, isUTC);\n  }\n\n  return new Khronos(input, format, localeKey, strict, isUTC);\n}\n\nmoment.utc = (input?: DateInput | Khronos, format?: string, localeKey?: string | boolean, strict?: boolean): Khronos => {\n  return _moment(input, format, localeKey, strict, true);\n};\n\nmoment.parseZone = (input?: DateInput | Khronos, format?: string, localeKey?: string | boolean, strict?: boolean): Khronos => {\n  return _moment(input, format, localeKey, strict, true).parseZone();\n};\n\nmoment.locale = getSetGlobalLocale;\nmoment.localeData = (key?: string | string[] | Khronos): Locale => {\n  if (key instanceof Khronos) {\n    return key.localeData();\n  }\n\n  return getLocale(key);\n};\n\n// moment.utc = createUTC;\nmoment.unix = (inp: number) => new Khronos(inp * 1000);\nmoment.ISO_8601 = ISO_8601;\nmoment.RFC_2822 = RFC_2822;\nmoment.defineLocale = defineLocale;\nmoment.parseTwoDigitYear = parseTwoDigitYear;\nmoment.isDate = isDate;\nmoment.invalid = function _invalid(): Khronos {\n  return new Khronos(new Date(NaN));\n};\n\n// duration(inp?: Duration | DateInput | Khronos, unit?: MomentUnitOfTime): Duration;\nmoment.duration = (input?: Duration | DateInput | Khronos, unit?: MomentUnitOfTime): Duration => {\n  const _unit = mapUnitOfTime(unit);\n  if (isDate(input)) {\n    throw new Error('todo implement');\n  }\n\n  if (input == null) {\n    return createDuration();\n  }\n\n  if (isDuration(input)) {\n    return createDuration(input, _unit, { _locale: input._locale });\n  }\n\n  if (isString(input) || isNumber(input) || isDuration(input) || isObject<DateObject>(input)) {\n    return createDuration(input, _unit);\n  }\n\n  throw new Error('todo implement');\n};\n\nmoment.min = function _min(...dates: ((DateInput | Khronos)[] | (DateInput | Khronos))[]): Khronos {\n  const _firstArg = dates[0];\n  const _dates = (isArray(_firstArg) ? _firstArg : dates)\n  // tslint:disable-next-line\n    .map((date: Khronos) => _moment(date))\n    .map(date => date.toDate());\n\n  const _date = min(..._dates);\n\n  return new Khronos(_date);\n};\n\nmoment.max = function _max(...dates: ((DateInput | Khronos)[] | (DateInput | Khronos))[]): Khronos {\n  const _firstArg = dates[0];\n  const _dates = (isArray(_firstArg) ? _firstArg : dates)\n  // tslint:disable-next-line\n    .map((date: Khronos) => _moment(date))\n    .map(date => date.toDate());\n\n  const _date = max(..._dates);\n\n  return new Khronos(_date);\n};\n\nmoment.locales = (): string[] => {\n  return listLocales();\n};\n\nexport interface MomentInputObject {\n  years?: number;\n  year?: number;\n  y?: number;\n\n  months?: number;\n  month?: number;\n  M?: number;\n\n  days?: number;\n  day?: number;\n  d?: number;\n\n  dates?: number;\n  date?: number;\n  D?: number;\n\n  hours?: number;\n  hour?: number;\n  h?: number;\n\n  minutes?: number;\n  minute?: number;\n  m?: number;\n\n  seconds?: number;\n  second?: number;\n  s?: number;\n\n  milliseconds?: number;\n  millisecond?: number;\n  ms?: number;\n\n  w?: number;\n  week?: number;\n  weeks?: number;\n\n  Q?: number;\n  quarter?: number;\n  quarters?: number;\n\n  weekYear?: number;\n}\n\nexport type MomentUnitOfTime = (\n  'year' | 'years' | 'y' |\n  'month' | 'months' | 'M' |\n  'week' | 'weeks' | 'w' |\n  'day' | 'days' | 'd' |\n  'hour' | 'hours' | 'h' |\n  'minute' | 'minutes' | 'm' |\n  'second' | 'seconds' | 's' |\n  'millisecond' | 'milliseconds' | 'ms' |\n  'q' | 'quarter' | 'quarters' | 'Q' |\n  'isoWeek' | 'isoWeeks' | 'W' |\n  'date' | 'dates' | 'D'\n  );\n\nexport type MomentAll = MomentUnitOfTime |\n  'weekYear' | 'weekYears' | 'gg' |\n  'isoWeekYear' | 'isoWeekYears' | 'GG' |\n  'dayOfYear' | 'dayOfYears' | 'DDD' |\n  'weekday' | 'weekdays' | 'e' |\n  'isoWeekday' | 'isoWeekdays' | 'E';\n\nconst _unitsPriority: {[key in UnitOfTime]: number} = {\n  year: 1,\n  month: 8,\n  week: 5,\n  isoWeek: 5,\n  day: 11,\n  weekday: 11,\n  isoWeekday: 11,\n  hours: 13,\n  weekYear: 1,\n  isoWeekYear: 1,\n  quarter: 7,\n  date: 9,\n  dayOfYear: 4,\n  minutes: 14,\n  seconds: 15,\n  milliseconds: 16\n};\n\n// todo: do I need 2 mappers?\nconst _timeHashMap: { [key in MomentAll]: UnitOfTime | string } = {\n  y: 'year',\n  years: 'year',\n  year: 'year',\n  M: 'month',\n  months: 'month',\n  month: 'month',\n  w: 'week',\n  weeks: 'week',\n  week: 'week',\n\n  d: 'day',\n  days: 'day',\n  day: 'day',\n\n  date: 'date',\n  dates: 'date',\n  D: 'date',\n\n  h: 'hours',\n  hour: 'hours',\n  hours: 'hours',\n  m: 'minutes',\n  minute: 'minutes',\n  minutes: 'minutes',\n  s: 'seconds',\n  second: 'seconds',\n  seconds: 'seconds',\n  ms: 'milliseconds',\n  millisecond: 'milliseconds',\n  milliseconds: 'milliseconds',\n  quarter: 'quarter',\n  quarters: 'quarter',\n  q: 'quarter',\n  Q: 'quarter',\n  isoWeek: 'isoWeek',\n  isoWeeks: 'isoWeek',\n  W: 'isoWeek',\n  weekYear: 'weekYear',\n  weekYears: 'weekYear',\n  gg: 'weekYears',\n  isoWeekYear: 'isoWeekYear',\n  isoWeekYears: 'isoWeekYear',\n  GG: 'isoWeekYear',\n  dayOfYear: 'dayOfYear',\n  dayOfYears: 'dayOfYear',\n  DDD: 'dayOfYear',\n  weekday: 'weekday',\n  weekdays: 'weekday',\n  e: 'weekday',\n  isoWeekday: 'isoWeekday',\n  isoWeekdays: 'isoWeekday',\n  E: 'isoWeekday'\n};\n\nfunction mapUnitOfTime(period: MomentAll): UnitOfTime {\n  return _timeHashMap[period] as UnitOfTime;\n}\n\nfunction mapMomentInputObject(obj: MomentInputObject): {[key in UnitOfTime]?: number} {\n  const _res: {[key in UnitOfTime]?: number} = {};\n\n  return Object.keys(obj)\n    .reduce((res, key: keyof MomentInputObject) => {\n      res[mapUnitOfTime(key)] = obj[key];\n\n      return res;\n    }, _res);\n}\n\nexport class Khronos {\n  _date: Date = new Date();\n  _isUTC = false;\n  _isStrict: boolean;\n  _locale: Locale;\n  _format: string | string[];\n  _offset: number;\n  _tzm: number;\n\n  constructor(input?: DateInput,\n              format?: string | string[],\n              localeKey?: string,\n              strict = false,\n              isUTC = false,\n              offset?: number) {\n    // locale will be needed to format invalid date message\n    this._locale = getLocale(localeKey);\n    // parse invalid input\n    if (input === '' || input === null || (isNumber(input) && isNaN(input))) {\n      this._date = new Date(NaN);\n\n      return this;\n    }\n\n    this._isUTC = isUTC;\n    if (this._isUTC) {\n      this._offset = 0;\n    }\n    if (offset || offset === 0) {\n      this._offset = offset;\n    }\n    this._isStrict = strict;\n    this._format = format;\n\n    if (!input && input !== 0 && !format) {\n      this._date = new Date();\n\n      return this;\n    }\n\n    if (isDate(input)) {\n      this._date = cloneDate(input);\n\n      return this;\n    }\n\n    // this._date = parseDate(input, format, localeKey, strict, isUTC);\n    const config = createLocalOrUTC(input, format, localeKey, strict, isUTC);\n    this._date = config._d;\n    this._offset = isNumber(config._offset) ? config._offset : this._offset;\n    this._isUTC = config._isUTC;\n    this._isStrict = config._strict;\n    this._format = config._f;\n    this._tzm = config._tzm;\n  }\n\n  _toConfig(): DateParsingConfig {\n    return { _isUTC: this._isUTC, _locale: this._locale, _offset: this._offset, _tzm: this._tzm };\n  }\n\n  // Locale\n  locale(): string;\n  locale(localeKey: string | string[] | Khronos): Khronos;\n  locale(localeKey?: string | string[] | Khronos): Khronos | string {\n    if (isUndefined(localeKey)) {\n      return this._locale._abbr;\n    }\n\n    if (localeKey instanceof Khronos) {\n      this._locale = localeKey._locale;\n\n      return this;\n    }\n\n    const newLocaleData = getLocale(localeKey);\n    if (newLocaleData != null) {\n      this._locale = newLocaleData;\n    }\n\n    return this;\n  }\n\n  localeData(): Locale {\n    return this._locale;\n  }\n\n  // Basic\n\n  add(val: number | string | MomentInputObject, period?: UnitOfTime | MomentUnitOfTime): Khronos {\n    if (isString(val)) {\n      this._date = add(this._date, parseInt(val, 10), mapUnitOfTime(period));\n    }\n\n    if (isNumber(val)) {\n      this._date = add(this._date, val, mapUnitOfTime(period));\n    }\n\n    if (isObject<MomentInputObject>(val)) {\n      const _mapped = mapMomentInputObject(val);\n      Object.keys(_mapped)\n        .forEach((key: UnitOfTime) => add(this._date, _mapped[key], key));\n    }\n\n    return this;\n  }\n\n  // fixme: for some reason here 'null' for time is fine\n  calendar(time?: DateInput | Khronos, formats?: CalendarSpec): string {\n    const _time = time instanceof Khronos ? time : new Khronos(time || new Date());\n    const _offset = (this._offset || 0) - (_time._offset || 0);\n    const _config = Object.assign(this._toConfig(), { _offset });\n\n    return calendar(this._date, _time._date,\n      formats, this._locale, _config);\n  }\n\n  clone(): Khronos {\n    const localeKey = this._locale && this._locale._abbr || 'en';\n\n    // return new Khronos(cloneDate(this._date), this._format, localeKey, this._isStrict, this._isUTC);\n    // fails if isUTC and offset\n    // return new Khronos(new Date(this.valueOf()),\n    return new Khronos(this._date,\n      this._format,\n      localeKey,\n      this._isStrict,\n      this._isUTC,\n      this._offset);\n  }\n\n  diff(b: DateInput | Khronos, unitOfTime?: MomentUnitOfTime, precise?: boolean): number {\n    const unit = mapUnitOfTime(unitOfTime);\n    const _b = b instanceof Khronos ? b : new Khronos(b);\n    // const zoneDelta = (_b.utcOffset() - this.utcOffset());\n    // const config = Object.assign(this._toConfig(), {\n    //   _offset: 0,\n    //   _isUTC: true,\n    //   _zoneDelta: zoneDelta\n    // });\n    // return diff(new Date(this.valueOf()), new Date(_b.valueOf()), unit, precise, config);\n\n    return diff(this._date, _b.toDate(), unit, precise, this._toConfig());\n  }\n\n  endOf(period?: MomentUnitOfTime): Khronos {\n    const _per = mapUnitOfTime(period);\n    this._date = endOf(this._date, _per, this._isUTC);\n\n    return this;\n  }\n\n  format(format?: string): string {\n    return formatDate(this._date, format, this._locale && this._locale._abbr, this._isUTC, this._offset);\n  }\n\n  // todo: implement\n  from(time?: DateInput | Khronos, withoutSuffix?: boolean): string {\n    const _time = _moment(time);\n    if (this.isValid() && _time.isValid()) {\n      return createDuration({ to: this.toDate(), from: _time.toDate() })\n        .locale(this.locale())\n        .humanize(!withoutSuffix);\n    }\n\n    return this.localeData().invalidDate;\n  }\n\n  fromNow(withoutSuffix?: boolean): string {\n    return this.from(new Date(), withoutSuffix);\n  }\n\n  to(inp: DateInput | Khronos, suffix?: boolean): string {\n    throw new Error(`TODO: Implement`);\n  }\n\n  toNow(withoutPrefix?: boolean): string {\n    throw new Error(`TODO: Implement`);\n  }\n\n  subtract(val: number | string | MomentInputObject, period?: UnitOfTime | MomentUnitOfTime): Khronos {\n    if (isString(val)) {\n      this._date = subtract(this._date, parseInt(val, 10), mapUnitOfTime(period));\n\n      return this;\n    }\n\n    if (isNumber(val)) {\n      this._date = subtract(this._date, val, mapUnitOfTime(period));\n    }\n\n    if (isObject<MomentInputObject>(val)) {\n      const _mapped = mapMomentInputObject(val);\n      Object.keys(_mapped)\n        .forEach((key: UnitOfTime) => subtract(this._date, _mapped[key], key));\n    }\n\n    return this;\n  }\n\n  get(period: MomentAll): number {\n    if (period === 'dayOfYear') {\n      return this.dayOfYear();\n    }\n\n    const unit = mapUnitOfTime(period);\n    switch (unit) {\n      case 'year':\n        return this.year();\n      case 'month':\n        return this.month();\n      // | 'week'\n      case 'date':\n        return this.date();\n      case 'day':\n        return this.day();\n      case 'hours':\n        return this.hours();\n      case 'minutes':\n        return this.minutes();\n      case 'seconds':\n        return this.seconds();\n      case 'milliseconds':\n        return this.milliseconds();\n      case 'week':\n        return this.week();\n      case 'isoWeek':\n        return this.isoWeek();\n      case 'weekYear':\n        return this.weekYear();\n      case 'isoWeekYear':\n        return this.isoWeekYear();\n      case 'weekday':\n        return this.weekday();\n      case 'isoWeekday':\n        return this.isoWeekday();\n      case 'quarter':\n        return this.quarter();\n      default:\n        throw new Error(`Unknown moment.get('${period}')`);\n    }\n  }\n\n  set(period: MomentAll | MomentInputObject, input?: number): Khronos {\n\n    if (isString(period)) {\n      const unit = mapUnitOfTime(period);\n      switch (unit) {\n        case 'year':\n          return this.year(input);\n        case 'month':\n          return this.month(input);\n        // | 'week'\n        case 'day':\n          return this.day(input);\n        case 'date':\n          return this.date(input);\n        case 'hours':\n          return this.hours(input);\n        case 'minutes':\n          return this.minutes(input);\n        case 'seconds':\n          return this.seconds(input);\n        case 'milliseconds':\n          return this.milliseconds(input);\n        case 'week':\n          return this.week(input);\n        case 'isoWeek':\n          return this.isoWeek(input);\n        case 'weekYear':\n          return this.weekYear(input);\n        case 'isoWeekYear':\n          return this.isoWeekYear(input);\n        case 'weekday':\n          return this.weekday(input);\n        case 'isoWeekday':\n          return this.isoWeekday(input);\n        case 'quarter':\n          return this.quarter(input);\n        default:\n          throw new Error(`Unknown moment.get('${period}')`);\n      }\n    }\n\n    if (isObject<MomentInputObject>(period)) {\n      const _mapped = mapMomentInputObject(period);\n      Object.keys(_mapped)\n        .sort(function(a: UnitOfTime, b: UnitOfTime): number {\n          return _unitsPriority[a] - _unitsPriority[b];\n        })\n        .forEach((key: UnitOfTime) => this.set(key, _mapped[key]));\n    }\n\n\n    return this;\n  }\n\n  toString(): string {\n    return this.format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n  }\n\n  toISOString(): string {\n    if (!this.isValid()) {\n      return null;\n    }\n\n    if (getFullYear(this._date, true) < 0 || getFullYear(this._date, true) > 9999) {\n      return this.format('YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n    }\n\n    if (isFunction(Date.prototype.toISOString)) {\n      // native implementation is ~50x faster, use it when we can\n      return this.toDate().toISOString();\n    }\n\n    return this.format('YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n  }\n\n  inspect(): string {\n    throw new Error('TODO: implement');\n  }\n\n  toJSON(): string {\n    return this.toISOString();\n  }\n\n  toDate(): Date {\n    return new Date(this.valueOf());\n  }\n\n  toObject(): {[key in MomentUnitOfTime]?: number} {\n    return {\n      // years: getFullYear(this._date, this._isUTC),\n      // months: getMonth(this._date, this._isUTC),\n\n      year: getFullYear(this._date, this._isUTC),\n      month: getMonth(this._date, this._isUTC),\n      date: getDate(this._date, this._isUTC),\n      hours: getHours(this._date, this._isUTC),\n      minutes: getMinutes(this._date, this._isUTC),\n      seconds: getSeconds(this._date, this._isUTC),\n      milliseconds: getMilliseconds(this._date, this._isUTC)\n    };\n  }\n\n  toArray(): DateArray {\n    return [this.year(), this.month(), this.date(), this.hour(), this.minute(), this.second(), this.millisecond()];\n  }\n\n\n  // Dates boolean algebra\n\n  isAfter(date: Khronos, unit?: MomentUnitOfTime): boolean {\n    const _unit = unit ? mapUnitOfTime(unit) : void 0;\n\n    return isAfter(this._date, date.toDate(), _unit);\n  }\n\n  isBefore(date: Khronos, unit?: MomentUnitOfTime): boolean {\n    const _unit = unit ? mapUnitOfTime(unit) : void 0;\n\n    return isBefore(this.toDate(), date.toDate(), _unit);\n  }\n\n  isBetween(from: Khronos, to: Khronos, unit?: MomentUnitOfTime, inclusivity?: string): boolean {\n    const _unit = unit ? mapUnitOfTime(unit) : void 0;\n\n    return isBetween(this.toDate(), from.toDate(), to.toDate(), _unit, inclusivity);\n  }\n\n  isSame(date: Khronos, unit?: MomentUnitOfTime): boolean {\n    const _unit = unit ? mapUnitOfTime(unit) : void 0;\n\n    return isSame(this._date, date.toDate(), _unit);\n  }\n\n  isSameOrAfter(date: Khronos, unit?: MomentUnitOfTime): boolean {\n    const _unit = unit ? mapUnitOfTime(unit) : void 0;\n\n    return isSameOrAfter(this._date, date.toDate(), _unit);\n  }\n\n  isSameOrBefore(date: Khronos, unit?: MomentUnitOfTime): boolean {\n    const _unit = unit ? mapUnitOfTime(unit) : void 0;\n\n    return isSameOrBefore(this._date, date.toDate(), _unit);\n  }\n\n  isValid(): boolean {\n    return isDateValid(this._date);\n  }\n\n  valueOf(): number {\n    return this._date.valueOf() - ((this._offset || 0) * 60000);\n  }\n\n  unix(): number {\n    // return getUnixTime(this._date);\n    return Math.floor(this.valueOf() / 1000);\n  }\n\n\n  // Offset\n\n  utcOffset(): number;\n  utcOffset(b: number | string, keepLocalTime?: boolean): Khronos;\n  utcOffset(b?: number | string, keepLocalTime?: boolean): number | Khronos {\n    const _config = this._toConfig();\n\n    if (!b && b !== 0) {\n      return getUTCOffset(this._date, _config);\n    }\n\n    this._date = setUTCOffset(this._date, b, keepLocalTime, false, _config);\n\n    this._offset = _config._offset;\n    this._isUTC = _config._isUTC;\n\n    return this;\n  }\n\n  utc(keepLocalTime?: boolean): Khronos {\n    return this.utcOffset(0, keepLocalTime);\n  }\n\n  local(keepLocalTime?: boolean): Khronos {\n    if (this._isUTC) {\n      this.utcOffset(0, keepLocalTime);\n      this._isUTC = false;\n\n      if (keepLocalTime) {\n        this.subtract(getDateOffset(this._date), 'm');\n      }\n    }\n\n    return this;\n  }\n\n  parseZone(input?: string): Khronos {\n    const _config = this._toConfig();\n    this._date = setOffsetToParsedOffset(this._date, input, _config);\n\n    this._offset = _config._offset;\n    this._isUTC = _config._isUTC;\n\n    return this;\n  }\n\n  hasAlignedHourOffset(input?: Khronos): boolean {\n    return hasAlignedHourOffset(this._date, input ? input._date : void 0);\n  }\n\n  isDST(): boolean {\n    return isDaylightSavingTime(this._date);\n  }\n\n  isLocal(): boolean {\n    return !this._isUTC;\n  }\n\n  isUtcOffset(): boolean {\n    return this._isUTC;\n  }\n\n  isUTC(): boolean {\n    return this.isUtc();\n  }\n\n  isUtc(): boolean {\n    return this._isUTC && this._offset === 0;\n  }\n\n  // Timezone\n\n  zoneAbbr(): string {\n    return getZoneAbbr(this._isUTC);\n  }\n\n  zoneName(): string {\n    return getZoneName(this._isUTC);\n  }\n\n  // Year\n\n  year(): number;\n  year(year: number): Khronos;\n  year(year?: number): Khronos | number {\n    if (!year && year !== 0) {\n      return getFullYear(this._date, this._isUTC);\n    }\n\n    this._date = cloneDate(setFullYear(this._date, year));\n\n    return this;\n  }\n\n  weekYear(): number;\n  weekYear(val: number): Khronos;\n  weekYear(val?: number): Khronos | number {\n    if (!val && val !== 0) {\n      return getWeekYear(this._date, this._locale, this.isUTC());\n    }\n\n    const date = getSetWeekYear(this._date, val, this._locale, this.isUTC());\n    if (isDate(date)) {\n      this._date = date;\n    }\n\n    return this;\n  }\n\n  isoWeekYear(): number ;\n  isoWeekYear(val: number): Khronos ;\n  isoWeekYear(val?: number): Khronos | number {\n    if (!val && val !== 0) {\n      return getISOWeekYear(this._date, this.isUTC());\n    }\n\n    const date = getSetISOWeekYear(this._date, val, this.isUtc());\n\n    if (isDate(date)) {\n      this._date = date;\n    }\n\n    return this;\n  }\n\n  isLeapYear(): boolean {\n    return isLeapYear(getFullYear(this.toDate(), this.isUTC()));\n  }\n\n  // Month\n\n  month(): number;\n  month(month: number | string): Khronos;\n  month(month?: number | string): Khronos | number {\n    if (!month && month !== 0) {\n      return getMonth(this._date, this._isUTC);\n    }\n\n    let _month = month;\n\n    if (isString(month)) {\n      const locale = this._locale || getLocale();\n      _month = locale.monthsParse(month);\n    }\n\n    if (isNumber(_month)) {\n      this._date = cloneDate(setMonth(this._date, _month, this._isUTC));\n    }\n\n    return this;\n  }\n\n  /** @deprecated */\n  hour(): number;\n  hour(hours: number): Khronos;\n  hour(hours?: number): Khronos | number {\n    return this.hours(hours);\n  }\n\n  hours(): number;\n  hours(hours: number): Khronos;\n  hours(hours?: number): Khronos | number {\n    if (!hours && hours !== 0) {\n      return getHours(this._date, this._isUTC);\n    }\n\n    this._date = cloneDate(setHours(this._date, hours, this._isUTC));\n\n    return this;\n  }\n\n  /** @deprecated */\n  minute(): number;\n  minute(minutes: number): Khronos;\n  minute(minutes?: number): Khronos | number {\n    return this.minutes(minutes);\n  }\n\n  minutes(): number;\n  minutes(minutes: number): Khronos;\n  minutes(minutes?: number): Khronos | number {\n    if (!minutes && minutes !== 0) {\n      return getMinutes(this._date, this._isUTC);\n    }\n\n    this._date = cloneDate(setMinutes(this._date, minutes, this._isUTC));\n\n    return this;\n  }\n\n  /** @deprecated */\n  second(): number;\n  second(seconds: number): Khronos;\n  second(seconds?: number): Khronos | number {\n    return this.seconds(seconds);\n  }\n\n  seconds(): number;\n  seconds(seconds: number): Khronos;\n  seconds(seconds?: number): Khronos | number {\n    if (!seconds && seconds !== 0) {\n      return getSeconds(this._date, this._isUTC);\n    }\n\n    this._date = cloneDate(setSeconds(this._date, seconds, this._isUTC));\n\n    return this;\n  }\n\n  /** @deprecated */\n  millisecond(): number;\n  millisecond(ms: number): Khronos;\n  millisecond(ms?: number): Khronos | number {\n    return this.milliseconds(ms);\n  }\n\n  milliseconds(): number;\n  milliseconds(seconds: number): Khronos;\n  milliseconds(seconds?: number): Khronos | number {\n    if (!seconds && seconds !== 0) {\n      return getMilliseconds(this._date, this._isUTC);\n    }\n\n    this._date = cloneDate(setMilliseconds(this._date, seconds, this._isUTC));\n\n    return this;\n  }\n\n  // Day\n\n  date(): number;\n  date(date: number): Khronos;\n  date(date?: number): Khronos | number {\n    if (!date && date !== 0) {\n      return getDate(this._date, this._isUTC);\n    }\n\n    this._date = cloneDate(setDate(this._date, date, this._isUTC));\n\n    return this;\n  }\n\n  day(): number ;\n  day(input: number | string): Khronos ;\n  day(input?: number | string): Khronos | number {\n    if (!input && input !== 0) {\n      return getDayOfWeek(this._date, this._isUTC);\n    }\n\n    let _input = input;\n\n    if (isString(input)) {\n      _input = parseWeekday(input, this._locale);\n    }\n\n    if (isNumber(_input)) {\n      this._date = setDayOfWeek(this._date, _input, this._locale, this._isUTC);\n    }\n\n    return this;\n  }\n\n  weekday(): number ;\n  weekday(val: number): Khronos ;\n  weekday(val?: number): Khronos | number {\n    if (!val && val !== 0) {\n      return getLocaleDayOfWeek(this._date, this._locale, this._isUTC);\n    }\n\n    this._date = setLocaleDayOfWeek(this._date, val, { locale: this._locale, isUTC: this._isUTC });\n\n    return this;\n  }\n\n  isoWeekday(): number ;\n  isoWeekday(val: number | string): Khronos ;\n  isoWeekday(val?: number | string): Khronos | number {\n    if (!val && val !== 0) {\n      return getISODayOfWeek(this._date);\n    }\n\n    this._date = setISODayOfWeek(this._date, val);\n\n    return this;\n  }\n\n  dayOfYear(): number;\n  dayOfYear(val: number): Khronos;\n  dayOfYear(val?: number): Khronos | number {\n    if (!val && val !== 0) {\n      return getDayOfYear(this._date);\n    }\n\n    this._date = setDayOfYear(this._date, val);\n\n    return this;\n  }\n\n  // Week\n\n  week(): number;\n  week(input: number): Khronos;\n  week(input?: number): Khronos | number {\n    if (!input && input !== 0) {\n      return getWeek(this._date, this._locale);\n    }\n\n    this._date = setWeek(this._date, input, this._locale);\n\n    return this;\n  }\n\n  /** @deprecated */\n  weeks(): number;\n  weeks(input: number): Khronos;\n  weeks(input?: number): Khronos | number {\n    return this.week(input);\n  }\n\n  isoWeek(): number ;\n  isoWeek(val: number): Khronos ;\n  isoWeek(val?: number): Khronos | number {\n    if (!val && val !== 0) {\n      return getISOWeek(this._date);\n    }\n\n    this._date = setISOWeek(this._date, val);\n\n    return this;\n  }\n\n  /** @deprecated */\n  isoWeeks(): number ;\n  isoWeeks(val: number): Khronos ;\n  isoWeeks(val?: number): Khronos | number {\n    return this.isoWeek(val);\n  }\n\n  weeksInYear(): number {\n    return getWeeksInYear(this._date, this._isUTC, this._locale);\n  }\n\n  isoWeeksInYear(): number {\n    return getISOWeeksInYear(this._date, this._isUTC);\n  }\n\n\n  daysInMonth(): number {\n    return daysInMonth(getFullYear(this._date, this._isUTC), getMonth(this._date, this._isUTC));\n  }\n\n\n  quarter(): number;\n  quarter(val: number): Khronos;\n  quarter(val?: number): Khronos | number {\n    if (!val && val !== 0) {\n      return getQuarter(this._date, this._isUTC);\n    }\n\n    this._date = setQuarter(this._date, val, this._isUTC);\n\n    return this;\n  }\n\n  /** @deprecated */\n  quarters(): number;\n  quarters(val: number): Khronos;\n  quarters(val?: number): Khronos | number {\n    return this.quarter(val);\n  }\n\n  startOf(period?: MomentUnitOfTime): Khronos {\n    const _per = mapUnitOfTime(period);\n    this._date = startOf(this._date, _per, this._isUTC);\n\n    return this;\n  }\n\n}\n"]}