ngx-bootstrap 3.0.1 → 3.1.4

package/chronos/esm5/duration/constructor.js

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { getLocale } from '../locale/locales';
+import { isDurationValid } from './valid';
+import { bubble, daysToMonths, monthsToDays } from './bubble';
+import { normalizeUnits } from '../units/aliases';
+import { relativeTime } from './humanize';
+import { toInt } from '../utils/type-checks';
+var Duration = /** @class */ (function () {
+    function Duration(duration, config) {
+        if (config === void 0) { config = {}; }
+        this._data = {};
+        this._locale = getLocale();
+        this._locale = config && config._locale || getLocale();
+        // const normalizedInput = normalizeObjectUnits(duration);
+        var /** @type {?} */ normalizedInput = duration;
+        var /** @type {?} */ years = normalizedInput.year || 0;
+        var /** @type {?} */ quarters = normalizedInput.quarter || 0;
+        var /** @type {?} */ months = normalizedInput.month || 0;
+        var /** @type {?} */ weeks = normalizedInput.week || 0;
+        var /** @type {?} */ days = normalizedInput.day || 0;
+        var /** @type {?} */ hours = normalizedInput.hours || 0;
+        var /** @type {?} */ minutes = normalizedInput.minutes || 0;
+        var /** @type {?} */ seconds = normalizedInput.seconds || 0;
+        var /** @type {?} */ milliseconds = normalizedInput.milliseconds || 0;
+        this._isValid = isDurationValid(normalizedInput);
+        // representation for dateAddRemove
+        this._milliseconds = +milliseconds +
+            seconds * 1000 +
+            minutes * 60 * 1000 + // 1000 * 60
+            // 1000 * 60
+            hours * 1000 * 60 * 60; // using 1000 * 60 * 60
+        // instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978
+        // Because of dateAddRemove treats 24 hours as different from a
+        // day when working around DST, we need to store them separately
+        this._days = +days +
+            weeks * 7;
+        // It is impossible to translate months into days without knowing
+        // which months you are are talking about, so we have to store
+        // it separately.
+        this._months = +months +
+            quarters * 3 +
+            years * 12;
+        // this._data = {};
+        // this._locale = getLocale();
+        // this._bubble();
+        return bubble(this);
+    }
+    /**
+     * @return {?}
+     */
+    Duration.prototype.isValid = /**
+     * @return {?}
+     */
+    function () {
+        return this._isValid;
+    };
+    /**
+     * @param {?=} withSuffix
+     * @return {?}
+     */
+    Duration.prototype.humanize = /**
+     * @param {?=} withSuffix
+     * @return {?}
+     */
+    function (withSuffix) {
+        // throw new Error(`TODO: implement`);
+        if (!this.isValid()) {
+            return this.localeData().invalidDate;
+        }
+        var /** @type {?} */ locale = this.localeData();
+        var /** @type {?} */ output = relativeTime(this, !withSuffix, locale);
+        if (withSuffix) {
+            output = locale.pastFuture(+this, output);
+        }
+        return locale.postformat(output);
+    };
+    /**
+     * @return {?}
+     */
+    Duration.prototype.localeData = /**
+     * @return {?}
+     */
+    function () {
+        return this._locale;
+    };
+    /**
+     * @param {?=} localeKey
+     * @return {?}
+     */
+    Duration.prototype.locale = /**
+     * @param {?=} localeKey
+     * @return {?}
+     */
+    function (localeKey) {
+        if (!localeKey) {
+            return this._locale._abbr;
+        }
+        this._locale = getLocale(localeKey) || this._locale;
+        return this;
+    };
+    /**
+     * @return {?}
+     */
+    Duration.prototype.abs = /**
+     * @return {?}
+     */
+    function () {
+        var /** @type {?} */ mathAbs = Math.abs;
+        var /** @type {?} */ data = this._data;
+        this._milliseconds = mathAbs(this._milliseconds);
+        this._days = mathAbs(this._days);
+        this._months = mathAbs(this._months);
+        data.milliseconds = mathAbs(data.milliseconds);
+        data.seconds = mathAbs(data.seconds);
+        data.minutes = mathAbs(data.minutes);
+        data.hours = mathAbs(data.hours);
+        data.month = mathAbs(data.month);
+        data.year = mathAbs(data.year);
+        return this;
+    };
+    /**
+     * @param {?} _units
+     * @return {?}
+     */
+    Duration.prototype.as = /**
+     * @param {?} _units
+     * @return {?}
+     */
+    function (_units) {
+        if (!this.isValid()) {
+            return NaN;
+        }
+        var /** @type {?} */ days;
+        var /** @type {?} */ months;
+        var /** @type {?} */ milliseconds = this._milliseconds;
+        var /** @type {?} */ units = normalizeUnits(_units);
+        if (units === 'month' || units === 'year') {
+            days = this._days + milliseconds / 864e5;
+            months = this._months + daysToMonths(days);
+            return units === 'month' ? months : months / 12;
+        }
+        // handle milliseconds separately because of floating point math errors (issue #1867)
+        days = this._days + Math.round(monthsToDays(this._months));
+        switch (units) {
+            case 'week':
+                return days / 7 + milliseconds / 6048e5;
+            case 'day':
+                return days + milliseconds / 864e5;
+            case 'hours':
+                return days * 24 + milliseconds / 36e5;
+            case 'minutes':
+                return days * 1440 + milliseconds / 6e4;
+            case 'seconds':
+                return days * 86400 + milliseconds / 1000;
+            // Math.floor prevents floating point math errors here
+            case 'milliseconds':
+                return Math.floor(days * 864e5) + milliseconds;
+            default:
+                throw new Error("Unknown unit " + units);
+        }
+    };
+    /**
+     * @return {?}
+     */
+    Duration.prototype.valueOf = /**
+     * @return {?}
+     */
+    function () {
+        if (!this.isValid()) {
+            return NaN;
+        }
+        return (this._milliseconds +
+            this._days * 864e5 +
+            (this._months % 12) * 2592e6 +
+            toInt(this._months / 12) * 31536e6);
+    };
+    return Duration;
+}());
+export { Duration };
+function Duration_tsickle_Closure_declarations() {
+    /** @type {?} */
+    Duration.prototype._milliseconds;
+    /** @type {?} */
+    Duration.prototype._days;
+    /** @type {?} */
+    Duration.prototype._months;
+    /** @type {?} */
+    Duration.prototype._data;
+    /** @type {?} */
+    Duration.prototype._locale;
+    /** @type {?} */
+    Duration.prototype._isValid;
+}
+/**
+ * @param {?} obj
+ * @return {?}
+ */
+export function isDuration(obj) {
+    return obj instanceof Duration;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constructor.js","sourceRoot":"ng://ngx-bootstrap/chronos/","sources":["duration/constructor.ts"],"names":[],"mappings":";;;;AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAE7C,IAAA;IAQE,kBAAY,QAA6B,EAAE,MAA8B;QAA9B,uBAAA,EAAA,WAA8B;qBAJ5C,EAAE;uBACb,SAAS,EAAE;QAI3B,IAAI,CAAC,OAAO,GAAG,MAAM,IAAI,MAAM,CAAC,OAAO,IAAI,SAAS,EAAE,CAAC;;QAEvD,qBAAM,eAAe,GAAG,QAAQ,CAAC;QACjC,qBAAM,KAAK,GAAG,eAAe,CAAC,IAAI,IAAI,CAAC,CAAC;QACxC,qBAAM,QAAQ,GAAG,eAAe,CAAC,OAAO,IAAI,CAAC,CAAC;QAC9C,qBAAM,MAAM,GAAG,eAAe,CAAC,KAAK,IAAI,CAAC,CAAC;QAC1C,qBAAM,KAAK,GAAG,eAAe,CAAC,IAAI,IAAI,CAAC,CAAC;QACxC,qBAAM,IAAI,GAAG,eAAe,CAAC,GAAG,IAAI,CAAC,CAAC;QACtC,qBAAM,KAAK,GAAG,eAAe,CAAC,KAAK,IAAI,CAAC,CAAC;QACzC,qBAAM,OAAO,GAAG,eAAe,CAAC,OAAO,IAAI,CAAC,CAAC;QAC7C,qBAAM,OAAO,GAAG,eAAe,CAAC,OAAO,IAAI,CAAC,CAAC;QAC7C,qBAAM,YAAY,GAAG,eAAe,CAAC,YAAY,IAAI,CAAC,CAAC;QAEvD,IAAI,CAAC,QAAQ,GAAG,eAAe,CAAC,eAAe,CAAC,CAAC;;QAGjD,IAAI,CAAC,aAAa,GAAG,CAAC,YAAY;YAChC,OAAO,GAAG,IAAI;YACd,OAAO,GAAG,EAAE,GAAG,IAAI,GAAG,YAAY;;YAClC,KAAK,GAAG,IAAI,GAAG,EAAE,GAAG,EAAE,CAAC;;;;QAIzB,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI;YAChB,KAAK,GAAG,CAAC,CAAC;;;;QAIZ,IAAI,CAAC,OAAO,GAAG,CAAC,MAAM;YACpB,QAAQ,GAAG,CAAC;YACZ,KAAK,GAAG,EAAE,CAAC;;;;QAOb,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;KACrB;;;;IAED,0BAAO;;;IAAP;QACE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC;KACtB;;;;;IAED,2BAAQ;;;;IAAR,UAAS,UAAoB;;QAG3B,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC;SACtC;QAED,qBAAM,MAAM,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QACjC,qBAAI,MAAM,GAAG,YAAY,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QAErD,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;YACf,MAAM,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;SAC3C;QAED,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;KAClC;;;;IAED,6BAAU;;;IAAV;QACE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC;KACrB;;;;;IAID,yBAAM;;;;IAAN,UAAO,SAAkB;QACvB,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;YACf,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;SAC3B;QAED,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC;QAEpD,MAAM,CAAC,IAAI,CAAC;KACb;;;;IAGD,sBAAG;;;IAAH;QACE,qBAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC;QAEzB,qBAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC;QAExB,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACjD,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAErC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC/C,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACrC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAE/B,MAAM,CAAC,IAAI,CAAC;KACb;;;;;IAED,qBAAE;;;;IAAF,UAAG,MAAc;QACf,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;YACpB,MAAM,CAAC,GAAG,CAAC;SACZ;QACD,qBAAI,IAAI,CAAC;QACT,qBAAI,MAAM,CAAC;QACX,qBAAM,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC;QAExC,qBAAM,KAAK,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;QAErC,EAAE,CAAC,CAAC,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,MAAM,CAAC,CAAC,CAAC;YAC1C,IAAI,GAAG,IAAI,CAAC,KAAK,GAAG,YAAY,GAAG,KAAK,CAAC;YACzC,MAAM,GAAG,IAAI,CAAC,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;YAE3C,MAAM,CAAC,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC;SACjD;;QAGD,IAAI,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAC3D,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;YACd,KAAK,MAAM;gBACT,MAAM,CAAC,IAAI,GAAG,CAAC,GAAG,YAAY,GAAG,MAAM,CAAC;YAC1C,KAAK,KAAK;gBACR,MAAM,CAAC,IAAI,GAAG,YAAY,GAAG,KAAK,CAAC;YACrC,KAAK,OAAO;gBACV,MAAM,CAAC,IAAI,GAAG,EAAE,GAAG,YAAY,GAAG,IAAI,CAAC;YACzC,KAAK,SAAS;gBACZ,MAAM,CAAC,IAAI,GAAG,IAAI,GAAG,YAAY,GAAG,GAAG,CAAC;YAC1C,KAAK,SAAS;gBACZ,MAAM,CAAC,IAAI,GAAG,KAAK,GAAG,YAAY,GAAG,IAAI,CAAC;;YAE5C,KAAK,cAAc;gBACjB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,GAAG,YAAY,CAAC;YACjD;gBACE,MAAM,IAAI,KAAK,CAAC,kBAAgB,KAAO,CAAC,CAAC;SAC5C;KACF;;;;IAED,0BAAO;;;IAAP;QACE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;YACpB,MAAM,CAAC,GAAG,CAAC;SACZ;QAED,MAAM,CAAC,CACL,IAAI,CAAC,aAAa;YAClB,IAAI,CAAC,KAAK,GAAG,KAAK;YAClB,CAAC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,MAAM;YAC5B,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,OAAO,CACnC,CAAC;KACH;mBArKH;IAsKC,CAAA;AA5JD,oBA4JC;;;;;;;;;;;;;;;;;;;AAED,MAAM,qBAAqB,GAAQ;IACjC,MAAM,CAAC,GAAG,YAAY,QAAQ,CAAC;CAChC","sourcesContent":["import { getLocale } from '../locale/locales';\nimport { DateParsingConfig } from '../create/parsing.types';\nimport { isDurationValid } from './valid';\nimport { bubble, daysToMonths, monthsToDays } from './bubble';\nimport { DateObject } from '../types';\nimport { Locale } from '../locale/locale.class';\nimport { normalizeUnits } from '../units/aliases';\nimport { relativeTime } from './humanize';\nimport { toInt } from '../utils/type-checks';\n\nexport class Duration {\n  _milliseconds: number;\n  _days: number;\n  _months: number;\n  _data: Partial<DateObject> = {};\n  _locale: Locale = getLocale();\n  _isValid: boolean;\n\n  constructor(duration: Partial<DateObject>, config: DateParsingConfig = {}) {\n    this._locale = config && config._locale || getLocale();\n    // const normalizedInput = normalizeObjectUnits(duration);\n    const normalizedInput = duration;\n    const years = normalizedInput.year || 0;\n    const quarters = normalizedInput.quarter || 0;\n    const months = normalizedInput.month || 0;\n    const weeks = normalizedInput.week || 0;\n    const days = normalizedInput.day || 0;\n    const hours = normalizedInput.hours || 0;\n    const minutes = normalizedInput.minutes || 0;\n    const seconds = normalizedInput.seconds || 0;\n    const milliseconds = normalizedInput.milliseconds || 0;\n\n    this._isValid = isDurationValid(normalizedInput);\n\n    // representation for dateAddRemove\n    this._milliseconds = +milliseconds +\n      seconds * 1000 +\n      minutes * 60 * 1000 + // 1000 * 60\n      hours * 1000 * 60 * 60; // using 1000 * 60 * 60\n    // instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n    // Because of dateAddRemove treats 24 hours as different from a\n    // day when working around DST, we need to store them separately\n    this._days = +days +\n      weeks * 7;\n    // It is impossible to translate months into days without knowing\n    // which months you are are talking about, so we have to store\n    // it separately.\n    this._months = +months +\n      quarters * 3 +\n      years * 12;\n\n    // this._data = {};\n\n    // this._locale = getLocale();\n\n    // this._bubble();\n    return bubble(this);\n  }\n\n  isValid(): boolean {\n    return this._isValid;\n  }\n\n  humanize(withSuffix?: boolean): string {\n    // throw new Error(`TODO: implement`);\n\n    if (!this.isValid()) {\n      return this.localeData().invalidDate;\n    }\n\n    const locale = this.localeData();\n    let output = relativeTime(this, !withSuffix, locale);\n\n    if (withSuffix) {\n      output = locale.pastFuture(+this, output);\n    }\n\n    return locale.postformat(output);\n  }\n\n  localeData(): Locale {\n    return this._locale;\n  }\n\n  locale(): string;\n  locale(localeKey: string): Duration;\n  locale(localeKey?: string): Duration | string {\n    if (!localeKey) {\n      return this._locale._abbr;\n    }\n\n    this._locale = getLocale(localeKey) || this._locale;\n\n    return this;\n  }\n\n\n  abs(): Duration {\n    const mathAbs = Math.abs;\n\n    const data = this._data;\n\n    this._milliseconds = mathAbs(this._milliseconds);\n    this._days = mathAbs(this._days);\n    this._months = mathAbs(this._months);\n\n    data.milliseconds = mathAbs(data.milliseconds);\n    data.seconds = mathAbs(data.seconds);\n    data.minutes = mathAbs(data.minutes);\n    data.hours = mathAbs(data.hours);\n    data.month = mathAbs(data.month);\n    data.year = mathAbs(data.year);\n\n    return this;\n  }\n\n  as(_units: string): number {\n    if (!this.isValid()) {\n      return NaN;\n    }\n    let days;\n    let months;\n    const milliseconds = this._milliseconds;\n\n    const units = normalizeUnits(_units);\n\n    if (units === 'month' || units === 'year') {\n      days = this._days + milliseconds / 864e5;\n      months = this._months + daysToMonths(days);\n\n      return units === 'month' ? months : months / 12;\n    }\n\n    // handle milliseconds separately because of floating point math errors (issue #1867)\n    days = this._days + Math.round(monthsToDays(this._months));\n    switch (units) {\n      case 'week'   :\n        return days / 7 + milliseconds / 6048e5;\n      case 'day'    :\n        return days + milliseconds / 864e5;\n      case 'hours'   :\n        return days * 24 + milliseconds / 36e5;\n      case 'minutes' :\n        return days * 1440 + milliseconds / 6e4;\n      case 'seconds' :\n        return days * 86400 + milliseconds / 1000;\n      // Math.floor prevents floating point math errors here\n      case 'milliseconds':\n        return Math.floor(days * 864e5) + milliseconds;\n      default:\n        throw new Error(`Unknown unit ${units}`);\n    }\n  }\n\n  valueOf () {\n    if (!this.isValid()) {\n      return NaN;\n    }\n\n    return (\n      this._milliseconds +\n      this._days * 864e5 +\n      (this._months % 12) * 2592e6 +\n      toInt(this._months / 12) * 31536e6\n    );\n  }\n}\n\nexport function isDuration(obj: any): obj is Duration {\n  return obj instanceof Duration;\n}\n"]}

package/chronos/esm5/duration/create.js

@@ -0,0 +1,143 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Duration, isDuration } from './constructor';
+import { isDateValid, isNumber, isObject, isString, toInt } from '../utils/type-checks';
+import { DATE, HOUR, MILLISECOND, MINUTE, SECOND } from '../units/constants';
+import { parseDate } from '../create/local';
+import { absRound } from '../utils/abs-round';
+import { cloneWithOffset } from '../units/offset';
+import { isAfter, isBefore } from '../utils/date-compare';
+import { getFullYear, getMonth } from '../utils/date-getters';
+import { add } from '../moment/add-subtract';
+import { cloneDate } from '../create/clone';
+var /** @type {?} */ aspNetRegex = /^(\-|\+)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)(\.\d*)?)?$/;
+// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
+// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
+// and further modified to allow for strings containing both week and day
+// tslint:disable-next-line
+var /** @type {?} */ isoRegex = /^(-|\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;
+/**
+ * @param {?=} input
+ * @param {?=} key
+ * @param {?=} config
+ * @return {?}
+ */
+export function createDuration(input, key, config) {
+    if (config === void 0) { config = {}; }
+    var /** @type {?} */ duration = convertDuration(input, key);
+    // matching against regexp is expensive, do it on demand
+    return new Duration(duration, config);
+}
+/**
+ * @param {?} input
+ * @param {?} key
+ * @return {?}
+ */
+function convertDuration(input, key) {
+    // checks for null or undefined
+    if (input == null) {
+        return {};
+    }
+    if (isDuration(input)) {
+        return {
+            milliseconds: input._milliseconds,
+            day: input._days,
+            month: input._months
+        };
+    }
+    if (isNumber(input)) {
+        // duration = {};
+        return key ? (_a = {}, _a[key] = input, _a) : { milliseconds: input };
+    }
+    if (isString(input)) {
+        var /** @type {?} */ match = aspNetRegex.exec(input);
+        if (match) {
+            var /** @type {?} */ sign = (match[1] === '-') ? -1 : 1;
+            return {
+                year: 0,
+                day: toInt(match[DATE]) * sign,
+                hours: toInt(match[HOUR]) * sign,
+                minutes: toInt(match[MINUTE]) * sign,
+                seconds: toInt(match[SECOND]) * sign,
+                // the millisecond decimal point is included in the match
+                milliseconds: toInt(absRound(toInt(match[MILLISECOND]) * 1000)) * sign
+            };
+        }
+        match = isoRegex.exec(input);
+        if (match) {
+            var /** @type {?} */ sign = (match[1] === '-') ? -1 : (match[1] === '+') ? 1 : 1;
+            return {
+                year: parseIso(match[2], sign),
+                month: parseIso(match[3], sign),
+                week: parseIso(match[4], sign),
+                day: parseIso(match[5], sign),
+                hours: parseIso(match[6], sign),
+                minutes: parseIso(match[7], sign),
+                seconds: parseIso(match[8], sign)
+            };
+        }
+    }
+    if (isObject(input) && ('from' in input || 'to' in input)) {
+        var /** @type {?} */ diffRes = momentsDifference(parseDate(input.from), parseDate(input.to));
+        return {
+            milliseconds: diffRes.milliseconds,
+            month: diffRes.months
+        };
+    }
+    return input;
+    var _a;
+}
+/**
+ * @param {?} inp
+ * @param {?} sign
+ * @return {?}
+ */
+function parseIso(inp, sign) {
+    // We'd normally use ~~inp for this, but unfortunately it also
+    // converts floats to ints.
+    // inp may be undefined, so careful calling replace on it.
+    var /** @type {?} */ res = inp && parseFloat(inp.replace(',', '.'));
+    // apply sign while we're at it
+    return (isNaN(res) ? 0 : res) * sign;
+}
+/**
+ * @param {?} base
+ * @param {?} other
+ * @return {?}
+ */
+function positiveMomentsDifference(base, other) {
+    var /** @type {?} */ res = { milliseconds: 0, months: 0 };
+    res.months = getMonth(other) - getMonth(base) +
+        (getFullYear(other) - getFullYear(base)) * 12;
+    var /** @type {?} */ _basePlus = add(cloneDate(base), res.months, 'month');
+    if (isAfter(_basePlus, other)) {
+        --res.months;
+    }
+    res.milliseconds = +other - +(add(cloneDate(base), res.months, 'month'));
+    return res;
+}
+/**
+ * @param {?} base
+ * @param {?} other
+ * @return {?}
+ */
+function momentsDifference(base, other) {
+    if (!(isDateValid(base) && isDateValid(other))) {
+        return { milliseconds: 0, months: 0 };
+    }
+    var /** @type {?} */ res;
+    var /** @type {?} */ _other = cloneWithOffset(other, base, { _offset: base.getTimezoneOffset() });
+    if (isBefore(base, _other)) {
+        res = positiveMomentsDifference(base, _other);
+    }
+    else {
+        res = positiveMomentsDifference(_other, base);
+        res.milliseconds = -res.milliseconds;
+        res.months = -res.months;
+    }
+    return res;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create.js","sourceRoot":"ng://ngx-bootstrap/chronos/","sources":["duration/create.ts"],"names":[],"mappings":"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","sourcesContent":["// ASP.NET json date format regex\nimport { Duration, isDuration } from './constructor';\nimport { isDateValid, isNumber, isObject, isString, toInt } from '../utils/type-checks';\nimport { DATE, HOUR, MILLISECOND, MINUTE, SECOND } from '../units/constants';\nimport { parseDate } from '../create/local';\nimport { absRound } from '../utils/abs-round';\nimport { DateObject } from '../types';\nimport { DateParsingConfig } from '../create/parsing.types';\nimport { cloneWithOffset } from '../units/offset';\nimport { isAfter, isBefore } from '../utils/date-compare';\nimport { getFullYear, getMonth } from '../utils/date-getters';\nimport { add } from '../moment/add-subtract';\nimport { cloneDate } from '../create/clone';\n\nconst aspNetRegex = /^(\\-|\\+)?(?:(\\d*)[. ])?(\\d+)\\:(\\d+)(?:\\:(\\d+)(\\.\\d*)?)?$/;\n\n// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n// and further modified to allow for strings containing both week and day\n// tslint:disable-next-line\nconst isoRegex = /^(-|\\+)?P(?:([-+]?[0-9,.]*)Y)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)W)?(?:([-+]?[0-9,.]*)D)?(?:T(?:([-+]?[0-9,.]*)H)?(?:([-+]?[0-9,.]*)M)?(?:([-+]?[0-9,.]*)S)?)?$/;\n\nexport type DurationInput = string | number | Duration | Partial<DateObject> | { from: Date; to: Date };\n\nexport function createDuration(input?: DurationInput, key?: string, config: DateParsingConfig = {}) {\n  const duration = convertDuration(input, key);\n  // matching against regexp is expensive, do it on demand\n\n  return new Duration(duration, config);\n}\n\nfunction convertDuration(input: any, key: string): Partial<DateObject> {\n  // checks for null or undefined\n  if (input == null) {\n    return {};\n  }\n\n  if (isDuration(input)) {\n    return {\n      milliseconds: input._milliseconds,\n      day: input._days,\n      month: input._months\n    };\n  }\n  if (isNumber(input)) {\n    // duration = {};\n    return key ? { [key]: input } : { milliseconds: input };\n  }\n\n  if (isString(input)) {\n    let match = aspNetRegex.exec(input);\n\n    if (match) {\n      const sign = (match[1] === '-') ? -1 : 1;\n\n      return {\n        year: 0,\n        day: toInt(match[DATE]) * sign,\n        hours: toInt(match[HOUR]) * sign,\n        minutes: toInt(match[MINUTE]) * sign,\n        seconds: toInt(match[SECOND]) * sign,\n        // the millisecond decimal point is included in the match\n        milliseconds: toInt(absRound(toInt(match[MILLISECOND]) * 1000)) * sign\n      };\n    }\n\n    match = isoRegex.exec(input);\n    if (match) {\n      const sign = (match[1] === '-') ? -1 : (match[1] === '+') ? 1 : 1;\n\n      return {\n        year: parseIso(match[2], sign),\n        month: parseIso(match[3], sign),\n        week: parseIso(match[4], sign),\n        day: parseIso(match[5], sign),\n        hours: parseIso(match[6], sign),\n        minutes: parseIso(match[7], sign),\n        seconds: parseIso(match[8], sign)\n      };\n    }\n\n  }\n\n  if (isObject<{from: any; to: any}>(input) && ('from' in input || 'to' in input)) {\n    const diffRes = momentsDifference(parseDate(input.from), parseDate(input.to));\n\n    return {\n      milliseconds: diffRes.milliseconds,\n      month: diffRes.months\n    };\n  }\n\n  return input;\n}\n\n// createDuration.fn = Duration.prototype;\n// createDuration.invalid = invalid;\n\nfunction parseIso(inp: string, sign: number): number {\n  // We'd normally use ~~inp for this, but unfortunately it also\n  // converts floats to ints.\n  // inp may be undefined, so careful calling replace on it.\n  const res = inp && parseFloat(inp.replace(',', '.'));\n  // apply sign while we're at it\n\n  return (isNaN(res) ? 0 : res) * sign;\n}\n\nfunction positiveMomentsDifference(base: Date, other: Date): { milliseconds: number; months: number } {\n  const res = { milliseconds: 0, months: 0 };\n\n  res.months = getMonth(other) - getMonth(base) +\n    (getFullYear(other) - getFullYear(base)) * 12;\n  const _basePlus = add(cloneDate(base), res.months, 'month');\n  if (isAfter(_basePlus, other)) {\n    --res.months;\n  }\n\n  res.milliseconds = +other - +(add(cloneDate(base), res.months, 'month'));\n\n  return res;\n}\n\nfunction momentsDifference(base: Date, other: Date): { milliseconds: number; months: number } {\n  if (!(isDateValid(base) && isDateValid(other))) {\n    return { milliseconds: 0, months: 0 };\n  }\n\n  let res;\n  const _other = cloneWithOffset(other, base, {_offset: base.getTimezoneOffset()});\n  if (isBefore(base, _other)) {\n    res = positiveMomentsDifference(base, _other);\n  } else {\n    res = positiveMomentsDifference(_other, base);\n    res.milliseconds = -res.milliseconds;\n    res.months = -res.months;\n  }\n\n  return res;\n}\n"]}

package/chronos/esm5/duration/humanize.js

@@ -0,0 +1,109 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { createDuration } from './create';
+var /** @type {?} */ round = Math.round;
+var /** @type {?} */ thresholds = {
+    ss: 44,
+    // a few seconds to seconds
+    s: 45,
+    // seconds to minute
+    m: 45,
+    // minutes to hour
+    h: 22,
+    // hours to day
+    d: 26,
+    // days to month
+    M: 11 // months to year
+};
+/**
+ * @param {?} str
+ * @param {?} num
+ * @param {?} withoutSuffix
+ * @param {?} isFuture
+ * @param {?} locale
+ * @return {?}
+ */
+function substituteTimeAgo(str, num, withoutSuffix, isFuture, locale) {
+    return locale.relativeTime(num || 1, !!withoutSuffix, str, isFuture);
+}
+/**
+ * @param {?} posNegDuration
+ * @param {?} withoutSuffix
+ * @param {?} locale
+ * @return {?}
+ */
+export function relativeTime(posNegDuration, withoutSuffix, locale) {
+    var /** @type {?} */ duration = createDuration(posNegDuration).abs();
+    var /** @type {?} */ seconds = round(duration.as('s'));
+    var /** @type {?} */ minutes = round(duration.as('m'));
+    var /** @type {?} */ hours = round(duration.as('h'));
+    var /** @type {?} */ days = round(duration.as('d'));
+    var /** @type {?} */ months = round(duration.as('M'));
+    var /** @type {?} */ years = round(duration.as('y'));
+    var /** @type {?} */ a = seconds <= thresholds["ss"] && ['s', seconds] ||
+        seconds < thresholds["s"] && ['ss', seconds] ||
+        minutes <= 1 && ['m'] ||
+        minutes < thresholds["m"] && ['mm', minutes] ||
+        hours <= 1 && ['h'] ||
+        hours < thresholds["h"] && ['hh', hours] ||
+        days <= 1 && ['d'] ||
+        days < thresholds["d"] && ['dd', days] ||
+        months <= 1 && ['M'] ||
+        months < thresholds["M"] && ['MM', months] ||
+        years <= 1 && ['y'] || ['yy', years];
+    var /** @type {?} */ b = [a[0], a[1], withoutSuffix, +posNegDuration > 0, locale];
+    // a[2] = withoutSuffix;
+    // a[3] = +posNegDuration > 0;
+    // a[4] = locale;
+    return substituteTimeAgo.apply(null, b);
+}
+/**
+ * @param {?} roundingFunction
+ * @return {?}
+ */
+export function getSetRelativeTimeRounding(roundingFunction) {
+    if (roundingFunction === undefined) {
+        return round;
+    }
+    if (typeof (roundingFunction) === 'function') {
+        round = roundingFunction;
+        return true;
+    }
+    return false;
+}
+/**
+ * @param {?} threshold
+ * @param {?} limit
+ * @return {?}
+ */
+export function getSetRelativeTimeThreshold(threshold, limit) {
+    if (thresholds[threshold] === undefined) {
+        return false;
+    }
+    if (limit === undefined) {
+        return thresholds[threshold];
+    }
+    thresholds[threshold] = limit;
+    if (threshold === 's') {
+        thresholds["ss"] = limit - 1;
+    }
+    return true;
+}
+// export function humanize(withSuffix) {
+//   if (!this.isValid()) {
+//     return this.localeData().invalidDate();
+//   }
+//
+//   const locale = this.localeData();
+//   let output = relativeTime(this, !withSuffix, locale);
+//
+//   if (withSuffix) {
+//     output = locale.pastFuture(+this, output);
+//   }
+//
+//   return locale.postformat(output);
+// }
+
+//# sourceMappingURL=data:application/json;base64,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

package/chronos/esm5/duration/valid.js

@@ -0,0 +1,54 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { toInt } from '../utils/type-checks';
+var /** @type {?} */ ordering = ['year', 'quarter', 'month', 'week', 'day', 'hours', 'minutes', 'seconds', 'milliseconds'];
+var ɵ0 = function (mem, order) {
+    mem[order] = true;
+    return mem;
+};
+var /** @type {?} */ orderingHash = ordering.reduce(ɵ0, {});
+/**
+ * @param {?} duration
+ * @return {?}
+ */
+export function isDurationValid(duration) {
+    var /** @type {?} */ durationKeys = Object.keys(duration);
+    if (durationKeys
+        .some(function (key) {
+        return (key in orderingHash)
+            && duration[key] === null
+            || isNaN(duration[key]);
+    })) {
+        return false;
+    }
+    // for (let key in duration) {
+    //   if (!(indexOf.call(ordering, key) !== -1 && (duration[key] == null || !isNaN(duration[key])))) {
+    //     return false;
+    //   }
+    // }
+    var /** @type {?} */ unitHasDecimal = false;
+    for (var /** @type {?} */ i = 0; i < ordering.length; ++i) {
+        if (duration[ordering[i]]) {
+            // only allow non-integers for smallest unit
+            if (unitHasDecimal) {
+                return false;
+            }
+            if (duration[ordering[i]] !== toInt(duration[ordering[i]])) {
+                unitHasDecimal = true;
+            }
+        }
+    }
+    return true;
+}
+// export function isValid() {
+//   return this._isValid;
+// }
+//
+// export function createInvalid(): Duration {
+//   return createDuration(NaN);
+// }
+export { ɵ0 };
+
+//# sourceMappingURL=data:application/json;base64,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

package/chronos/esm5/format/format.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { zeroFill } from '../utils/zero-fill';
+import { isFunction } from '../utils/type-checks';
+export var /** @type {?} */ formatFunctions = {};
+export var /** @type {?} */ formatTokenFunctions = {};
+// tslint:disable-next-line
+export var /** @type {?} */ formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
+/**
+ * @param {?} token
+ * @param {?} padded
+ * @param {?} ordinal
+ * @param {?} callback
+ * @return {?}
+ */
+export function addFormatToken(token, padded, ordinal, callback) {
+    if (token) {
+        formatTokenFunctions[token] = callback;
+    }
+    if (padded) {
+        formatTokenFunctions[padded[0]] = function () {
+            return zeroFill(callback.apply(null, arguments), padded[1], padded[2]);
+        };
+    }
+    if (ordinal) {
+        formatTokenFunctions[ordinal] = function (date, opts) {
+            return opts.locale.ordinal(callback.apply(null, arguments), token);
+        };
+    }
+}
+/**
+ * @param {?} format
+ * @return {?}
+ */
+export function makeFormatFunction(format) {
+    var /** @type {?} */ array = format.match(formattingTokens);
+    var /** @type {?} */ length = array.length;
+    var /** @type {?} */ formatArr = new Array(length);
+    for (var /** @type {?} */ i = 0; i < length; i++) {
+        formatArr[i] = formatTokenFunctions[array[i]]
+            ? formatTokenFunctions[array[i]]
+            : removeFormattingTokens(array[i]);
+    }
+    return function (date, locale, isUTC, offset) {
+        if (offset === void 0) { offset = 0; }
+        var /** @type {?} */ output = '';
+        for (var /** @type {?} */ j = 0; j < length; j++) {
+            output += isFunction(formatArr[j])
+                ? (/** @type {?} */ (formatArr[j])).call(null, date, { format: format, locale: locale, isUTC: isUTC, offset: offset })
+                : formatArr[j];
+        }
+        return output;
+    };
+}
+/**
+ * @param {?} input
+ * @return {?}
+ */
+function removeFormattingTokens(input) {
+    if (input.match(/\[[\s\S]/)) {
+        return input.replace(/^\[|\]$/g, '');
+    }
+    return input.replace(/\\/g, '');
+}
+
+//# sourceMappingURL=data:application/json;base64,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