ngx-bootstrap 3.0.1 → 3.1.4

package/chronos/esm2015/locale/locale.defaults.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { defaultDayOfMonthOrdinalParse, defaultLocaleMonths, defaultLocaleMonthsShort, defaultLocaleWeekdays, defaultLocaleWeekdaysMin, defaultLocaleWeekdaysShort, defaultLongDateFormat, defaultOrdinal } from './locale.class';
+import { defaultCalendar } from './calendar';
+export const /** @type {?} */ defaultInvalidDate = 'Invalid date';
+export const /** @type {?} */ defaultLocaleWeek = {
+    dow: 0,
+    // Sunday is the first day of the week.
+    doy: 6 // The week that contains Jan 1st is the first week of the year.
+};
+export const /** @type {?} */ defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
+export const /** @type {?} */ defaultRelativeTime = {
+    future: 'in %s',
+    past: '%s ago',
+    s: 'a few seconds',
+    ss: '%d seconds',
+    m: 'a minute',
+    mm: '%d minutes',
+    h: 'an hour',
+    hh: '%d hours',
+    d: 'a day',
+    dd: '%d days',
+    M: 'a month',
+    MM: '%d months',
+    y: 'a year',
+    yy: '%d years'
+};
+export const /** @type {?} */ baseConfig = {
+    calendar: defaultCalendar,
+    longDateFormat: defaultLongDateFormat,
+    invalidDate: defaultInvalidDate,
+    ordinal: defaultOrdinal,
+    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,
+    relativeTime: defaultRelativeTime,
+    months: defaultLocaleMonths,
+    monthsShort: defaultLocaleMonthsShort,
+    week: defaultLocaleWeek,
+    weekdays: defaultLocaleWeekdays,
+    weekdaysMin: defaultLocaleWeekdaysMin,
+    weekdaysShort: defaultLocaleWeekdaysShort,
+    meridiemParse: defaultLocaleMeridiemParse
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/chronos/esm2015/locale/locales.js

@@ -0,0 +1,272 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { Locale } from './locale.class';
+import { baseConfig } from './locale.defaults';
+import { hasOwnProp, isArray, isObject, isString, isUndefined, toInt } from '../utils/type-checks';
+import { compareArrays } from '../utils/compare-arrays';
+import { initWeek } from '../units/week';
+import { initWeekYear } from '../units/week-year';
+import { initYear } from '../units/year';
+import { initTimezone } from '../units/timezone';
+import { initTimestamp } from '../units/timestamp';
+import { initSecond } from '../units/second';
+import { initQuarter } from '../units/quarter';
+import { initOffset } from '../units/offset';
+import { initMinute } from '../units/minute';
+import { initMillisecond } from '../units/millisecond';
+import { initMonth } from '../units/month';
+import { initHour } from '../units/hour';
+import { initDayOfYear } from '../units/day-of-year';
+import { initDayOfWeek } from '../units/day-of-week';
+import { initDayOfMonth } from '../units/day-of-month';
+const /** @type {?} */ locales = {};
+const /** @type {?} */ localeFamilies = {};
+let /** @type {?} */ globalLocale;
+/**
+ * @param {?} key
+ * @return {?}
+ */
+function normalizeLocale(key) {
+    return key ? key.toLowerCase().replace('_', '-') : key;
+}
+/**
+ * @param {?} names
+ * @return {?}
+ */
+function chooseLocale(names) {
+    let /** @type {?} */ next;
+    let /** @type {?} */ locale;
+    let /** @type {?} */ i = 0;
+    while (i < names.length) {
+        const /** @type {?} */ split = normalizeLocale(names[i]).split('-');
+        let /** @type {?} */ j = split.length;
+        next = normalizeLocale(names[i + 1]);
+        next = next ? next.split('-') : null;
+        while (j > 0) {
+            locale = loadLocale(split.slice(0, j).join('-'));
+            if (locale) {
+                return locale;
+            }
+            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
+                // the next array item is better than a shallower substring of this one
+                break;
+            }
+            j--;
+        }
+        i++;
+    }
+    return null;
+}
+/**
+ * @param {?} parentConfig
+ * @param {?} childConfig
+ * @return {?}
+ */
+export function mergeConfigs(parentConfig, childConfig) {
+    const /** @type {?} */ res = Object.assign({}, parentConfig);
+    for (const /** @type {?} */ childProp in childConfig) {
+        if (!hasOwnProp(childConfig, childProp)) {
+            continue;
+        }
+        if (isObject(parentConfig[childProp]) && isObject(childConfig[childProp])) {
+            res[childProp] = {};
+            Object.assign(res[childProp], parentConfig[childProp]);
+            Object.assign(res[childProp], childConfig[childProp]);
+        }
+        else if (childConfig[childProp] != null) {
+            res[childProp] = childConfig[childProp];
+        }
+        else {
+            delete res[childProp];
+        }
+    }
+    let /** @type {?} */ parentProp;
+    for (parentProp in parentConfig) {
+        if (hasOwnProp(parentConfig, parentProp) &&
+            !hasOwnProp(childConfig, parentProp) &&
+            isObject(parentConfig[/** @type {?} */ (parentProp)])) {
+            // make sure changes to properties don't modify parent config
+            res[/** @type {?} */ (parentProp)] = Object.assign({}, res[/** @type {?} */ (parentProp)]);
+        }
+    }
+    return res;
+}
+/**
+ * @param {?} name
+ * @return {?}
+ */
+function loadLocale(name) {
+    // no way!
+    /* var oldLocale = null;
+       // TODO: Find a better way to register and load all the locales in Node
+       if (!locales[name] && (typeof module !== 'undefined') &&
+         module && module.exports) {
+         try {
+           oldLocale = globalLocale._abbr;
+           var aliasedRequire = require;
+           aliasedRequire('./locale/' + name);
+           getSetGlobalLocale(oldLocale);
+         } catch (e) {}
+       }*/
+    if (!locales[name]) {
+        // tslint:disable-next-line
+        console.error(`Khronos locale error: please load locale "${name}" before using it`);
+        // throw new Error(`Khronos locale error: please load locale "${name}" before using it`);
+    }
+    return locales[name];
+}
+/**
+ * @param {?=} key
+ * @param {?=} values
+ * @return {?}
+ */
+export function getSetGlobalLocale(key, values) {
+    let /** @type {?} */ data;
+    if (key) {
+        if (isUndefined(values)) {
+            data = getLocale(key);
+        }
+        else if (isString(key)) {
+            data = defineLocale(key, values);
+        }
+        if (data) {
+            globalLocale = data;
+        }
+    }
+    return globalLocale && globalLocale._abbr;
+}
+/**
+ * @param {?} name
+ * @param {?=} config
+ * @return {?}
+ */
+export function defineLocale(name, config) {
+    if (config === null) {
+        // useful for testing
+        delete locales[name];
+        globalLocale = getLocale('en');
+        return null;
+    }
+    if (!config) {
+        return;
+    }
+    let /** @type {?} */ parentConfig = baseConfig;
+    config.abbr = name;
+    if (config.parentLocale != null) {
+        if (locales[config.parentLocale] != null) {
+            parentConfig = locales[config.parentLocale]._config;
+        }
+        else {
+            if (!localeFamilies[config.parentLocale]) {
+                localeFamilies[config.parentLocale] = [];
+            }
+            localeFamilies[config.parentLocale].push({ name, config });
+            return null;
+        }
+    }
+    locales[name] = new Locale(mergeConfigs(parentConfig, config));
+    if (localeFamilies[name]) {
+        localeFamilies[name].forEach(function (x) {
+            defineLocale(x.name, x.config);
+        });
+    }
+    // backwards compat for now: also set the locale
+    // make sure we set the locale AFTER all child locales have been
+    // created, so we won't end up with the child locale set.
+    getSetGlobalLocale(name);
+    return locales[name];
+}
+/**
+ * @param {?} name
+ * @param {?=} config
+ * @return {?}
+ */
+export function updateLocale(name, config) {
+    let /** @type {?} */ _config = config;
+    if (_config != null) {
+        let /** @type {?} */ parentConfig = baseConfig;
+        // MERGE
+        const /** @type {?} */ tmpLocale = loadLocale(name);
+        if (tmpLocale != null) {
+            parentConfig = tmpLocale._config;
+        }
+        _config = mergeConfigs(parentConfig, _config);
+        const /** @type {?} */ locale = new Locale(_config);
+        locale.parentLocale = locales[name];
+        locales[name] = locale;
+        // backwards compat for now: also set the locale
+        getSetGlobalLocale(name);
+    }
+    else {
+        // pass null for config to unupdate, useful for tests
+        if (locales[name] != null) {
+            if (locales[name].parentLocale != null) {
+                locales[name] = locales[name].parentLocale;
+            }
+            else if (locales[name] != null) {
+                delete locales[name];
+            }
+        }
+    }
+    return locales[name];
+}
+/**
+ * @param {?=} key
+ * @return {?}
+ */
+export function getLocale(key) {
+    setDefaultLocale();
+    if (!key) {
+        return globalLocale;
+    }
+    // let locale;
+    const /** @type {?} */ _key = isArray(key) ? key : [key];
+    return chooseLocale(_key);
+}
+/**
+ * @return {?}
+ */
+export function listLocales() {
+    return Object.keys(locales);
+}
+/**
+ * @return {?}
+ */
+function setDefaultLocale() {
+    if (locales[`en`]) {
+        return undefined;
+    }
+    getSetGlobalLocale('en', {
+        dayOfMonthOrdinalParse: /\d{1,2}(th|st|nd|rd)/,
+        /**
+         * @param {?} num
+         * @return {?}
+         */
+        ordinal(num) {
+            const /** @type {?} */ b = num % 10;
+            const /** @type {?} */ output = toInt((num % 100) / 10) === 1
+                ? 'th'
+                : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';
+            return num + output;
+        }
+    });
+    initWeek();
+    initWeekYear();
+    initYear();
+    initTimezone();
+    initTimestamp();
+    initSecond();
+    initQuarter();
+    initOffset();
+    initMonth();
+    initMinute();
+    initMillisecond();
+    initHour();
+    initDayOfYear();
+    initDayOfWeek();
+    initDayOfMonth();
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"locales.js","sourceRoot":"ng://ngx-bootstrap/chronos/","sources":["locale/locales.ts"],"names":[],"mappings":"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","sourcesContent":["// internal storage for locale config files\nimport { Locale, LocaleData } from './locale.class';\nimport { baseConfig } from './locale.defaults';\nimport { hasOwnProp, isArray, isObject, isString, isUndefined, toInt } from '../utils/type-checks';\nimport { compareArrays } from '../utils/compare-arrays';\n\nimport { initWeek } from '../units/week';\nimport { initWeekYear } from '../units/week-year';\nimport { initYear } from '../units/year';\nimport { initTimezone } from '../units/timezone';\nimport { initTimestamp } from '../units/timestamp';\nimport { initSecond } from '../units/second';\nimport { initQuarter } from '../units/quarter';\nimport { initOffset } from '../units/offset';\nimport { initMinute } from '../units/minute';\nimport { initMillisecond } from '../units/millisecond';\nimport { initMonth } from '../units/month';\nimport { initHour } from '../units/hour';\nimport { initDayOfYear } from '../units/day-of-year';\nimport { initDayOfWeek } from '../units/day-of-week';\nimport { initDayOfMonth } from '../units/day-of-month';\n\nconst locales: { [key: string]: Locale } = {};\nconst localeFamilies: { [key: string]: {name: string; config: LocaleData}[] } = {};\nlet globalLocale: Locale;\n\nfunction normalizeLocale(key: string): string {\n  return key ? key.toLowerCase().replace('_', '-') : key;\n}\n\n// pick the locale from the array\n// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n// substring from most specific to least,\n// but move to the next array item if it's a more specific variant than the current root\nfunction chooseLocale(names: string[]): Locale {\n  let next;\n  let locale;\n  let i = 0;\n\n  while (i < names.length) {\n    const split = normalizeLocale(names[i]).split('-');\n    let j = split.length;\n    next = normalizeLocale(names[i + 1]);\n    next = next ? next.split('-') : null;\n    while (j > 0) {\n      locale = loadLocale(split.slice(0, j).join('-'));\n      if (locale) {\n        return locale;\n      }\n      if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {\n        // the next array item is better than a shallower substring of this one\n        break;\n      }\n      j--;\n    }\n    i++;\n  }\n\n  return null;\n}\n\nexport function mergeConfigs(parentConfig: LocaleData,\n                             childConfig: LocaleData) {\n  const res: LocaleData = Object.assign({}, parentConfig);\n\n  for (const childProp in childConfig) {\n    if (!hasOwnProp(childConfig, childProp)) {\n      continue;\n    }\n    if (isObject(parentConfig[childProp]) && isObject(childConfig[childProp])) {\n      res[childProp] = {};\n      Object.assign(res[childProp], parentConfig[childProp]);\n      Object.assign(res[childProp], childConfig[childProp]);\n    } else if (childConfig[childProp] != null) {\n      res[childProp] = childConfig[childProp];\n    } else {\n      delete res[childProp];\n    }\n  }\n  let parentProp;\n  for (parentProp in parentConfig) {\n    if (\n      hasOwnProp(parentConfig, parentProp) &&\n      !hasOwnProp(childConfig, parentProp) &&\n      isObject(parentConfig[parentProp as keyof LocaleData])\n    ) {\n      // make sure changes to properties don't modify parent config\n      res[parentProp as keyof LocaleData] = Object.assign({}, res[parentProp as keyof LocaleData]);\n    }\n  }\n\n  return res;\n}\n\n\nfunction loadLocale(name: string): Locale {\n  // no way!\n  /* var oldLocale = null;\n   // TODO: Find a better way to register and load all the locales in Node\n   if (!locales[name] && (typeof module !== 'undefined') &&\n     module && module.exports) {\n     try {\n       oldLocale = globalLocale._abbr;\n       var aliasedRequire = require;\n       aliasedRequire('./locale/' + name);\n       getSetGlobalLocale(oldLocale);\n     } catch (e) {}\n   }*/\n  if (!locales[name]) {\n    // tslint:disable-next-line\n    console.error(`Khronos locale error: please load locale \"${name}\" before using it`);\n    // throw new Error(`Khronos locale error: please load locale \"${name}\" before using it`);\n  }\n\n  return locales[name];\n}\n\n// This function will load locale and then set the global locale.  If\n// no arguments are passed in, it will simply return the current global\n// locale key.\nexport function getSetGlobalLocale(key?: string | string[], values?: LocaleData): string {\n  let data: Locale;\n\n  if (key) {\n    if (isUndefined(values)) {\n      data = getLocale(key);\n    } else if (isString(key)) {\n      data = defineLocale(key, values);\n    }\n\n    if (data) {\n      globalLocale = data;\n    }\n  }\n\n  return globalLocale && globalLocale._abbr;\n}\n\nexport function defineLocale(name: string, config?: LocaleData): Locale {\n  if (config === null) {\n    // useful for testing\n    delete locales[name];\n    globalLocale = getLocale('en');\n\n    return null;\n  }\n\n  if (!config) {\n    return;\n  }\n\n  let parentConfig = baseConfig;\n  config.abbr = name;\n  if (config.parentLocale != null) {\n    if (locales[config.parentLocale] != null) {\n      parentConfig = locales[config.parentLocale]._config;\n    } else {\n      if (!localeFamilies[config.parentLocale]) {\n        localeFamilies[config.parentLocale] = [];\n      }\n      localeFamilies[config.parentLocale].push({ name, config });\n\n      return null;\n    }\n  }\n\n  locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n  if (localeFamilies[name]) {\n    localeFamilies[name].forEach(function (x) {\n      defineLocale(x.name, x.config);\n    });\n  }\n\n  // backwards compat for now: also set the locale\n  // make sure we set the locale AFTER all child locales have been\n  // created, so we won't end up with the child locale set.\n  getSetGlobalLocale(name);\n\n\n  return locales[name];\n}\n\nexport function updateLocale(name: string, config?: LocaleData): Locale {\n  let _config = config;\n\n  if (_config != null) {\n    let parentConfig = baseConfig;\n    // MERGE\n    const tmpLocale = loadLocale(name);\n    if (tmpLocale != null) {\n      parentConfig = tmpLocale._config;\n    }\n    _config = mergeConfigs(parentConfig, _config);\n    const locale = new Locale(_config);\n    locale.parentLocale = locales[name];\n    locales[name] = locale;\n\n    // backwards compat for now: also set the locale\n    getSetGlobalLocale(name);\n  } else {\n    // pass null for config to unupdate, useful for tests\n    if (locales[name] != null) {\n      if (locales[name].parentLocale != null) {\n        locales[name] = locales[name].parentLocale;\n      } else if (locales[name] != null) {\n        delete locales[name];\n      }\n    }\n  }\n\n  return locales[name];\n}\n\n// returns locale data\nexport function getLocale(key?: string | string[]): Locale {\n  setDefaultLocale();\n\n  if (!key) {\n    return globalLocale;\n  }\n  // let locale;\n  const _key = isArray(key) ? key : [key];\n\n  return chooseLocale(_key);\n}\n\nexport function listLocales(): string[] {\n  return Object.keys(locales);\n}\n\nfunction setDefaultLocale(): void {\n  if (locales[`en`]) {\n\n    return undefined;\n  }\n\n  getSetGlobalLocale('en', {\n    dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n    ordinal(num: number): string {\n      const b = num % 10;\n      const output =\n        toInt((num % 100) / 10) === 1\n          ? 'th'\n          : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';\n\n      return num + output;\n    }\n  });\n\n  initWeek();\n  initWeekYear();\n  initYear();\n  initTimezone();\n  initTimestamp();\n  initSecond();\n  initQuarter();\n  initOffset();\n  initMonth();\n  initMinute();\n  initMillisecond();\n  initHour();\n  initDayOfYear();\n  initDayOfWeek();\n  initDayOfMonth();\n}\n"]}

package/chronos/esm2015/moment/add-subtract.js

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { createDuration } from '../duration/create';
+import { absRound } from '../utils/abs-round';
+import { getDate, getMonth, getTime } from '../utils/date-getters';
+import { setDate, setMonth, setTime } from '../utils/date-setters';
+import { cloneDate } from '../create/clone';
+/**
+ * @param {?} date
+ * @param {?} val
+ * @param {?} period
+ * @param {?=} isUTC
+ * @return {?}
+ */
+export function add(date, val, period, isUTC) {
+    const /** @type {?} */ dur = createDuration(val, period);
+    return addSubtract(date, dur, 1, isUTC);
+}
+/**
+ * @param {?} date
+ * @param {?} val
+ * @param {?} period
+ * @param {?=} isUTC
+ * @return {?}
+ */
+export function subtract(date, val, period, isUTC) {
+    const /** @type {?} */ dur = createDuration(val, period);
+    return addSubtract(date, dur, -1, isUTC);
+}
+/**
+ * @param {?} date
+ * @param {?} duration
+ * @param {?} isAdding
+ * @param {?=} isUTC
+ * @return {?}
+ */
+export function addSubtract(date, duration, isAdding, isUTC) {
+    const /** @type {?} */ milliseconds = duration._milliseconds;
+    const /** @type {?} */ days = absRound(duration._days);
+    const /** @type {?} */ months = absRound(duration._months);
+    // todo: add timezones support
+    // const _updateOffset = updateOffset == null ? true : updateOffset;
+    if (months) {
+        setMonth(date, getMonth(date, isUTC) + months * isAdding, isUTC);
+    }
+    if (days) {
+        setDate(date, getDate(date, isUTC) + days * isAdding, isUTC);
+    }
+    if (milliseconds) {
+        setTime(date, getTime(date) + milliseconds * isAdding);
+    }
+    return cloneDate(date);
+    // todo: add timezones support
+    // if (_updateOffset) {
+    //   hooks.updateOffset(date, days || months);
+    // }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/chronos/esm2015/moment/calendar.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { diff } from './diff';
+import { cloneWithOffset } from '../units/offset';
+import { isFunction, isString } from '../utils/type-checks';
+import { cloneDate } from '../create/clone';
+import { startOf } from '../utils/start-end-of';
+import { formatDate } from '../format';
+import { getLocale } from '../locale/locales';
+/**
+ * @record
+ */
+export function CalendarSpec() { }
+function CalendarSpec_tsickle_Closure_declarations() {
+    /** @type {?|undefined} */
+    CalendarSpec.prototype.sameDay;
+    /** @type {?|undefined} */
+    CalendarSpec.prototype.nextDay;
+    /** @type {?|undefined} */
+    CalendarSpec.prototype.lastDay;
+    /** @type {?|undefined} */
+    CalendarSpec.prototype.nextWeek;
+    /** @type {?|undefined} */
+    CalendarSpec.prototype.lastWeek;
+    /** @type {?|undefined} */
+    CalendarSpec.prototype.sameElse;
+    /* TODO: handle strange member:
+    [x: string]: CalendarSpecVal | void;
+    */
+}
+/**
+ * @param {?} date
+ * @param {?} now
+ * @param {?} config
+ * @return {?}
+ */
+export function getCalendarFormat(date, now, config) {
+    const /** @type {?} */ _diff = diff(date, now, 'day', true, config);
+    switch (true) {
+        case _diff < -6: return 'sameElse';
+        case _diff < -1: return 'lastWeek';
+        case _diff < 0: return 'lastDay';
+        case _diff < 1: return 'sameDay';
+        case _diff < 2: return 'nextDay';
+        case _diff < 7: return 'nextWeek';
+        default: return 'sameElse';
+    }
+}
+/**
+ * @param {?} date
+ * @param {?} time
+ * @param {?} formats
+ * @param {?=} locale
+ * @param {?=} config
+ * @return {?}
+ */
+export function calendar(date, time, formats, locale = getLocale(), config = {}) {
+    // We want to compare the start of today, vs this.
+    // Getting start-of-today depends on whether we're local/utc/offset or not.
+    const /** @type {?} */ now = time;
+    const /** @type {?} */ sod = startOf(cloneWithOffset(now, date, config), 'day', config._isUTC);
+    const /** @type {?} */ format = getCalendarFormat(date, sod, { _isUTC: true, _offset: 0 }) || 'sameElse';
+    let /** @type {?} */ output;
+    if (formats) {
+        const /** @type {?} */ _format = formats[format];
+        if (isString(_format)) {
+            output = _format;
+        }
+        if (isFunction(_format)) {
+            output = _format.call(null, date, now);
+        }
+    }
+    if (!output) {
+        output = locale.calendar(format, date, cloneDate(now));
+    }
+    return formatDate(date, output, config._locale._abbr, config._isUTC, config._offset);
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/chronos/esm2015/moment/diff.js

@@ -0,0 +1,88 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { cloneWithOffset, getDateOffset, getUTCOffset } from '../units/offset';
+import { absFloor } from '../utils';
+import { isDateValid, isNumber } from '../utils/type-checks';
+import { getFullYear, getMonth } from '../utils/date-getters';
+import { add } from './add-subtract';
+import { cloneDate } from '../create/clone';
+/**
+ * @param {?} date
+ * @param {?} input
+ * @param {?} units
+ * @param {?} asFloat
+ * @param {?=} config
+ * @return {?}
+ */
+export function diff(date, input, units, asFloat, config = {}) {
+    if (!isDateValid(date)) {
+        return NaN;
+    }
+    const /** @type {?} */ that = cloneWithOffset(input, date, config);
+    if (!isDateValid(that)) {
+        return NaN;
+    }
+    const /** @type {?} */ zoneOffset = (getDateOffset(input) - getDateOffset(date)) * 6e4;
+    const /** @type {?} */ zoneDelta = isNumber(config._zoneDelta)
+        ? config._zoneDelta * 6e4
+        : (getUTCOffset(input, config) - getUTCOffset(date, config)) * 6e4;
+    let /** @type {?} */ output;
+    switch (units) {
+        case 'year':
+            output = monthDiff(date, that) / 12;
+            break;
+        case 'month':
+            output = monthDiff(date, that);
+            break;
+        case 'quarter':
+            output = monthDiff(date, that) / 3;
+            break;
+        case 'seconds':
+            output = (date.valueOf() - that.valueOf()) / 1e3;
+            break; // 1000
+        case 'minutes':
+            output = (date.valueOf() - that.valueOf()) / 6e4;
+            break; // 1000 * 60
+        case 'hours':
+            output = (date.valueOf() - that.valueOf()) / 36e5;
+            break; // 1000 * 60 * 60
+        case 'day':
+            output = (date.valueOf() - that.valueOf() - (zoneDelta === 0 ? zoneOffset : zoneDelta)) / 864e5;
+            break; // 1000 * 60 * 60 * 24, negate dst
+        case 'week':
+            output = (date.valueOf() - that.valueOf() - zoneDelta) / 6048e5;
+            break; // 1000 * 60 * 60 * 24 * 7, negate dst
+        default:
+            output = date.valueOf() - that.valueOf();
+    }
+    return asFloat ? output : absFloor(output);
+}
+/**
+ * @param {?} a
+ * @param {?} b
+ * @return {?}
+ */
+function monthDiff(a, b) {
+    // difference in months
+    const /** @type {?} */ wholeMonthDiff = ((getFullYear(b) - getFullYear(a)) * 12) + (getMonth(b) - getMonth(a));
+    // b is in (anchor - 1 month, anchor + 1 month)
+    const /** @type {?} */ anchor = add(cloneDate(a), wholeMonthDiff, 'month');
+    let /** @type {?} */ anchor2;
+    let /** @type {?} */ adjust;
+    if (b.valueOf() - anchor.valueOf() < 0) {
+        anchor2 = add(cloneDate(a), wholeMonthDiff - 1, 'month');
+        // linear across the month
+        adjust = (b.valueOf() - anchor.valueOf()) / (anchor.valueOf() - anchor2.valueOf());
+    }
+    else {
+        anchor2 = add(cloneDate(a), wholeMonthDiff + 1, 'month');
+        // linear across the month
+        adjust = (b.valueOf() - anchor.valueOf()) / (anchor2.valueOf() - anchor.valueOf());
+    }
+    // check for negative zero, return zero if negative zero
+    return -(wholeMonthDiff + adjust) || 0;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"diff.js","sourceRoot":"ng://ngx-bootstrap/chronos/","sources":["moment/diff.ts"],"names":[],"mappings":"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","sourcesContent":["import { cloneWithOffset, getDateOffset, getUTCOffset } from '../units/offset';\nimport { DateParsingConfig } from '../create/parsing.types';\nimport { UnitOfTime } from '../types';\nimport { absFloor } from '../utils';\nimport { isDateValid, isNumber } from '../utils/type-checks';\nimport { getFullYear, getMonth } from '../utils/date-getters';\nimport { add } from './add-subtract';\nimport { cloneDate } from '../create/clone';\n\nexport function diff(date: Date, input: Date,\n                     units: UnitOfTime, asFloat: boolean,\n                     config: DateParsingConfig = {}\n                     ): number {\n  if (!isDateValid(date)) {\n    return NaN;\n  }\n\n  const that = cloneWithOffset(input, date, config);\n\n  if (!isDateValid(that)) {\n    return NaN;\n  }\n\n  const zoneOffset = (getDateOffset(input) - getDateOffset(date)) * 6e4;\n  const zoneDelta = isNumber(config._zoneDelta)\n    ? config._zoneDelta * 6e4\n    : (getUTCOffset(input, config) - getUTCOffset(date, config)) * 6e4;\n\n  let output;\n  switch (units) {\n    case 'year':\n      output = monthDiff(date, that) / 12;\n      break;\n    case 'month':\n      output = monthDiff(date, that);\n      break;\n    case 'quarter':\n      output = monthDiff(date, that) / 3;\n      break;\n    case 'seconds':\n      output = (date.valueOf() - that.valueOf()) / 1e3;\n      break; // 1000\n    case 'minutes':\n      output = (date.valueOf() - that.valueOf()) / 6e4;\n      break; // 1000 * 60\n    case 'hours':\n      output = (date.valueOf() - that.valueOf()) / 36e5;\n      break; // 1000 * 60 * 60\n    case 'day':\n      output = (date.valueOf() - that.valueOf() - (zoneDelta === 0 ? zoneOffset : zoneDelta)) / 864e5;\n      break; // 1000 * 60 * 60 * 24, negate dst\n    case 'week':\n      output = (date.valueOf() - that.valueOf() - zoneDelta) / 6048e5;\n      break; // 1000 * 60 * 60 * 24 * 7, negate dst\n    default:\n      output = date.valueOf() - that.valueOf();\n  }\n\n  return asFloat ? output : absFloor(output);\n}\n\nfunction monthDiff(a: Date, b: Date): number {\n  // difference in months\n  const wholeMonthDiff = ((getFullYear(b) - getFullYear(a)) * 12) + (getMonth(b) - getMonth(a));\n// b is in (anchor - 1 month, anchor + 1 month)\n  const anchor = add(cloneDate(a), wholeMonthDiff, 'month');\n  let anchor2;\n  let adjust;\n\n\n  if (b.valueOf() - anchor.valueOf() < 0) {\n    anchor2 = add(cloneDate(a), wholeMonthDiff - 1, 'month');\n    // linear across the month\n    adjust = (b.valueOf() - anchor.valueOf()) / (anchor.valueOf() - anchor2.valueOf());\n  } else {\n    anchor2 = add(cloneDate(a), wholeMonthDiff + 1, 'month');\n    // linear across the month\n    adjust = (b.valueOf() - anchor.valueOf()) / (anchor2.valueOf() - anchor.valueOf());\n  }\n\n  // check for negative zero, return zero if negative zero\n  return -(wholeMonthDiff + adjust) || 0;\n}\n"]}