ngx-bootstrap 3.0.1 → 3.1.4

package/chronos/esm5/create/from-string.js

@@ -0,0 +1,268 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { defaultLocaleMonthsShort, defaultLocaleWeekdaysShort } from '../locale/locale.class';
+import { isString } from '../utils/type-checks';
+import { configFromStringAndFormat } from './from-string-and-format';
+import { createUTCDate } from './date-from-array';
+import { createInvalid, markInvalid } from './valid';
+import { getParsingFlags } from './parsing-flags';
+// iso 8601 regex
+// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
+// tslint:disable-next-line
+var /** @type {?} */ extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+// tslint:disable-next-line
+var /** @type {?} */ basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?$/;
+var /** @type {?} */ tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
+var /** @type {?} */ isoDates = [
+    ['YYYYYY-MM-DD', /[+-]\d{6}-\d\d-\d\d/, true],
+    ['YYYY-MM-DD', /\d{4}-\d\d-\d\d/, true],
+    ['GGGG-[W]WW-E', /\d{4}-W\d\d-\d/, true],
+    ['GGGG-[W]WW', /\d{4}-W\d\d/, false],
+    ['YYYY-DDD', /\d{4}-\d{3}/, true],
+    ['YYYY-MM', /\d{4}-\d\d/, false],
+    ['YYYYYYMMDD', /[+-]\d{10}/, true],
+    ['YYYYMMDD', /\d{8}/, true],
+    // YYYYMM is NOT allowed by the standard
+    ['GGGG[W]WWE', /\d{4}W\d{3}/, true],
+    ['GGGG[W]WW', /\d{4}W\d{2}/, false],
+    ['YYYYDDD', /\d{7}/, true]
+];
+// iso time formats and regexes
+var /** @type {?} */ isoTimes = [
+    ['HH:mm:ss.SSSS', /\d\d:\d\d:\d\d\.\d+/],
+    ['HH:mm:ss,SSSS', /\d\d:\d\d:\d\d,\d+/],
+    ['HH:mm:ss', /\d\d:\d\d:\d\d/],
+    ['HH:mm', /\d\d:\d\d/],
+    ['HHmmss.SSSS', /\d\d\d\d\d\d\.\d+/],
+    ['HHmmss,SSSS', /\d\d\d\d\d\d,\d+/],
+    ['HHmmss', /\d\d\d\d\d\d/],
+    ['HHmm', /\d\d\d\d/],
+    ['HH', /\d\d/]
+];
+var /** @type {?} */ aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
+var /** @type {?} */ obsOffsets = {
+    UT: 0,
+    GMT: 0,
+    EDT: -4 * 60,
+    EST: -5 * 60,
+    CDT: -5 * 60,
+    CST: -6 * 60,
+    MDT: -6 * 60,
+    MST: -7 * 60,
+    PDT: -7 * 60,
+    PST: -8 * 60
+};
+// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3
+// tslint:disable-next-line
+var /** @type {?} */ rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\s)?(\d{1,2})\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s(\d{2,4})\s(\d\d):(\d\d)(?::(\d\d))?\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\d{4}))$/;
+/**
+ * @param {?} config
+ * @return {?}
+ */
+export function configFromISO(config) {
+    if (!isString(config._i)) {
+        return config;
+    }
+    var /** @type {?} */ input = config._i;
+    var /** @type {?} */ match = extendedIsoRegex.exec(input) || basicIsoRegex.exec(input);
+    var /** @type {?} */ allowTime;
+    var /** @type {?} */ dateFormat;
+    var /** @type {?} */ timeFormat;
+    var /** @type {?} */ tzFormat;
+    if (!match) {
+        config._isValid = false;
+        return config;
+    }
+    // getParsingFlags(config).iso = true;
+    var /** @type {?} */ i;
+    var /** @type {?} */ l;
+    for (i = 0, l = isoDates.length; i < l; i++) {
+        if (isoDates[i][1].exec(match[1])) {
+            dateFormat = isoDates[i][0];
+            allowTime = isoDates[i][2] !== false;
+            break;
+        }
+    }
+    if (dateFormat == null) {
+        config._isValid = false;
+        return config;
+    }
+    if (match[3]) {
+        for (i = 0, l = isoTimes.length; i < l; i++) {
+            if (isoTimes[i][1].exec(match[3])) {
+                // match[2] should be 'T' or space
+                timeFormat = (match[2] || ' ') + isoTimes[i][0];
+                break;
+            }
+        }
+        if (timeFormat == null) {
+            config._isValid = false;
+            return config;
+        }
+    }
+    if (!allowTime && timeFormat != null) {
+        config._isValid = false;
+        return config;
+    }
+    if (match[4]) {
+        if (tzRegex.exec(match[4])) {
+            tzFormat = 'Z';
+        }
+        else {
+            config._isValid = false;
+            return config;
+        }
+    }
+    config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
+    return configFromStringAndFormat(config);
+}
+/**
+ * @param {?} yearStr
+ * @param {?} monthStr
+ * @param {?} dayStr
+ * @param {?} hourStr
+ * @param {?} minuteStr
+ * @param {?} secondStr
+ * @return {?}
+ */
+function extractFromRFC2822Strings(yearStr, monthStr, dayStr, hourStr, minuteStr, secondStr) {
+    var /** @type {?} */ result = [
+        untruncateYear(yearStr),
+        defaultLocaleMonthsShort.indexOf(monthStr),
+        parseInt(dayStr, 10),
+        parseInt(hourStr, 10),
+        parseInt(minuteStr, 10)
+    ];
+    if (secondStr) {
+        result.push(parseInt(secondStr, 10));
+    }
+    return result;
+}
+/**
+ * @param {?} yearStr
+ * @return {?}
+ */
+function untruncateYear(yearStr) {
+    var /** @type {?} */ year = parseInt(yearStr, 10);
+    return year <= 49 ? year + 2000 : year;
+}
+/**
+ * @param {?} str
+ * @return {?}
+ */
+function preprocessRFC2822(str) {
+    // Remove comments and folding whitespace and replace multiple-spaces with a single space
+    return str
+        .replace(/\([^)]*\)|[\n\t]/g, ' ')
+        .replace(/(\s\s+)/g, ' ').trim();
+}
+/**
+ * @param {?} weekdayStr
+ * @param {?} parsedInput
+ * @param {?} config
+ * @return {?}
+ */
+function checkWeekday(weekdayStr, parsedInput, config) {
+    if (weekdayStr) {
+        // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.
+        var /** @type {?} */ weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr);
+        var /** @type {?} */ weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();
+        if (weekdayProvided !== weekdayActual) {
+            getParsingFlags(config).weekdayMismatch = true;
+            config._isValid = false;
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @param {?} obsOffset
+ * @param {?} militaryOffset
+ * @param {?} numOffset
+ * @return {?}
+ */
+function calculateOffset(obsOffset, militaryOffset, numOffset) {
+    if (obsOffset) {
+        return obsOffsets[obsOffset];
+    }
+    else if (militaryOffset) {
+        // the only allowed military tz is Z
+        return 0;
+    }
+    else {
+        var /** @type {?} */ hm = parseInt(numOffset, 10);
+        var /** @type {?} */ m = hm % 100;
+        var /** @type {?} */ h = (hm - m) / 100;
+        return h * 60 + m;
+    }
+}
+/**
+ * @param {?} config
+ * @return {?}
+ */
+export function configFromRFC2822(config) {
+    if (!isString(config._i)) {
+        return config;
+    }
+    var /** @type {?} */ match = rfc2822.exec(preprocessRFC2822(config._i));
+    if (!match) {
+        return markInvalid(config);
+    }
+    var /** @type {?} */ parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);
+    if (!checkWeekday(match[1], parsedArray, config)) {
+        return config;
+    }
+    config._a = parsedArray;
+    config._tzm = calculateOffset(match[8], match[9], match[10]);
+    config._d = createUTCDate.apply(null, config._a);
+    config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+    getParsingFlags(config).rfc2822 = true;
+    return config;
+}
+/**
+ * @param {?} config
+ * @return {?}
+ */
+export function configFromString(config) {
+    if (!isString(config._i)) {
+        return config;
+    }
+    var /** @type {?} */ matched = aspNetJsonRegex.exec(config._i);
+    if (matched !== null) {
+        config._d = new Date(+matched[1]);
+        return config;
+    }
+    // todo: update logic processing
+    // isISO -> configFromISO
+    // isRFC -> configFromRFC
+    configFromISO(config);
+    if (config._isValid === false) {
+        delete config._isValid;
+    }
+    else {
+        return config;
+    }
+    configFromRFC2822(config);
+    if (config._isValid === false) {
+        delete config._isValid;
+    }
+    else {
+        return config;
+    }
+    // Final attempt, use Input Fallback
+    // hooks.createFromInputFallback(config);
+    return createInvalid(config);
+}
+// hooks.createFromInputFallback = deprecate(
+//     'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +
+//     'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +
+//     'discouraged and will be removed in an upcoming major release. Please refer to ' +
+//     'http://momentjs.com/guides/#/warnings/js-date/ for more info.',
+//     function (config) {
+//         config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));
+//     }
+// );
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"from-string.js","sourceRoot":"ng://ngx-bootstrap/chronos/","sources":["create/from-string.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable-next-line\nimport { defaultLocaleMonthsShort, defaultLocaleWeekdaysShort } from '../locale/locale.class';\nimport { DateArray } from '../types';\nimport { DateParsingConfig } from './parsing.types';\nimport { isString } from '../utils/type-checks';\nimport { configFromStringAndFormat } from './from-string-and-format';\nimport { createUTCDate } from './date-from-array';\nimport { createInvalid, markInvalid } from './valid';\nimport { getParsingFlags } from './parsing-flags';\n\n// iso 8601 regex\n// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\n// tslint:disable-next-line\nconst extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n// tslint:disable-next-line\nconst basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n\nconst tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\nconst isoDates: [string, RegExp, boolean][] = [\n  ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/, true],\n  ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/, true],\n  ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/, true],\n  ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n  ['YYYY-DDD', /\\d{4}-\\d{3}/, true],\n  ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n  ['YYYYYYMMDD', /[+-]\\d{10}/, true],\n  ['YYYYMMDD', /\\d{8}/, true],\n  // YYYYMM is NOT allowed by the standard\n  ['GGGG[W]WWE', /\\d{4}W\\d{3}/, true],\n  ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n  ['YYYYDDD', /\\d{7}/, true]\n];\n\n// iso time formats and regexes\nconst isoTimes: [string, RegExp][] = [\n  ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n  ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n  ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n  ['HH:mm', /\\d\\d:\\d\\d/],\n  ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n  ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n  ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n  ['HHmm', /\\d\\d\\d\\d/],\n  ['HH', /\\d\\d/]\n];\n\nconst aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\nconst obsOffsets: { [key: string]: number } = {\n  UT: 0,\n  GMT: 0,\n  EDT: -4 * 60,\n  EST: -5 * 60,\n  CDT: -5 * 60,\n  CST: -6 * 60,\n  MDT: -6 * 60,\n  MST: -7 * 60,\n  PDT: -7 * 60,\n  PST: -8 * 60\n};\n\n// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\n// tslint:disable-next-line\nconst rfc2822 = /^(?:(Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d{1,2})\\s(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(\\d{2,4})\\s(\\d\\d):(\\d\\d)(?::(\\d\\d))?\\s(?:(UT|GMT|[ECMP][SD]T)|([Zz])|([+-]\\d{4}))$/;\n\n// date from iso format\nexport function configFromISO(config: DateParsingConfig): DateParsingConfig {\n  if (!isString(config._i)) {\n    return config;\n  }\n\n  const input = config._i;\n  const match = extendedIsoRegex.exec(input) || basicIsoRegex.exec(input);\n\n\n  let allowTime;\n  let dateFormat;\n  let timeFormat;\n  let tzFormat;\n\n  if (!match) {\n    config._isValid = false;\n\n    return config;\n  }\n\n  // getParsingFlags(config).iso = true;\n  let i;\n  let l;\n  for (i = 0, l = isoDates.length; i < l; i++) {\n    if (isoDates[i][1].exec(match[1])) {\n      dateFormat = isoDates[i][0];\n      allowTime = isoDates[i][2] !== false;\n      break;\n    }\n  }\n\n  if (dateFormat == null) {\n    config._isValid = false;\n\n    return config;\n  }\n\n  if (match[3]) {\n    for (i = 0, l = isoTimes.length; i < l; i++) {\n      if (isoTimes[i][1].exec(match[3])) {\n        // match[2] should be 'T' or space\n        timeFormat = (match[2] || ' ') + isoTimes[i][0];\n        break;\n      }\n    }\n\n    if (timeFormat == null) {\n      config._isValid = false;\n\n      return config;\n    }\n\n  }\n  if (!allowTime && timeFormat != null) {\n    config._isValid = false;\n\n    return config;\n  }\n\n  if (match[4]) {\n    if (tzRegex.exec(match[4])) {\n      tzFormat = 'Z';\n    } else {\n      config._isValid = false;\n\n      return config;\n    }\n  }\n\n  config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n\n  return configFromStringAndFormat(config);\n}\n\n// tslint:disable-next-line\nfunction extractFromRFC2822Strings(yearStr: string, monthStr: string, dayStr: string, hourStr: string, minuteStr: string, secondStr: string): DateArray {\n  const result = [\n    untruncateYear(yearStr),\n    defaultLocaleMonthsShort.indexOf(monthStr),\n    parseInt(dayStr, 10),\n    parseInt(hourStr, 10),\n    parseInt(minuteStr, 10)\n  ];\n\n  if (secondStr) {\n    result.push(parseInt(secondStr, 10));\n  }\n\n  return result;\n}\n\nfunction untruncateYear(yearStr: string): number {\n  const year = parseInt(yearStr, 10);\n\n  return year <= 49 ? year + 2000 : year;\n}\n\nfunction preprocessRFC2822(str: string): string {\n  // Remove comments and folding whitespace and replace multiple-spaces with a single space\n  return str\n    .replace(/\\([^)]*\\)|[\\n\\t]/g, ' ')\n    .replace(/(\\s\\s+)/g, ' ').trim();\n}\n\nfunction checkWeekday(weekdayStr: string, parsedInput: DateArray, config: DateParsingConfig): boolean {\n  if (weekdayStr) {\n    // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.\n    const weekdayProvided = defaultLocaleWeekdaysShort.indexOf(weekdayStr);\n    const weekdayActual = new Date(parsedInput[0], parsedInput[1], parsedInput[2]).getDay();\n    if (weekdayProvided !== weekdayActual) {\n      getParsingFlags(config).weekdayMismatch = true;\n      config._isValid = false;\n\n      return false;\n    }\n  }\n\n  return true;\n}\n\nfunction calculateOffset(obsOffset: string, militaryOffset: string, numOffset: string) {\n  if (obsOffset) {\n    return obsOffsets[obsOffset];\n  } else if (militaryOffset) {\n    // the only allowed military tz is Z\n    return 0;\n  } else {\n    const hm = parseInt(numOffset, 10);\n    const m = hm % 100;\n    const h = (hm - m) / 100;\n\n    return h * 60 + m;\n  }\n}\n\n// date and time from ref 2822 format\nexport function configFromRFC2822(config: DateParsingConfig): DateParsingConfig {\n  if (!isString(config._i)) {\n    return config;\n  }\n\n  const match = rfc2822.exec(preprocessRFC2822(config._i));\n\n  if (!match) {\n    return markInvalid(config);\n  }\n\n  const parsedArray = extractFromRFC2822Strings(match[4], match[3], match[2], match[5], match[6], match[7]);\n  if (!checkWeekday(match[1], parsedArray, config)) {\n    return config;\n  }\n\n  config._a = parsedArray;\n  config._tzm = calculateOffset(match[8], match[9], match[10]);\n\n  config._d = createUTCDate.apply(null, config._a);\n  config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n\n  getParsingFlags(config).rfc2822 = true;\n\n  return config;\n}\n\n// date from iso format or fallback\nexport function configFromString(config: DateParsingConfig): DateParsingConfig {\n  if (!isString(config._i)) {\n    return config;\n  }\n\n  const matched = aspNetJsonRegex.exec(config._i);\n\n  if (matched !== null) {\n    config._d = new Date(+matched[1]);\n\n    return config;\n  }\n\n  // todo: update logic processing\n  // isISO -> configFromISO\n  // isRFC -> configFromRFC\n\n  configFromISO(config);\n  if (config._isValid === false) {\n    delete config._isValid;\n  } else {\n    return config;\n  }\n\n  configFromRFC2822(config);\n  if (config._isValid === false) {\n    delete config._isValid;\n  } else {\n    return config;\n  }\n\n  // Final attempt, use Input Fallback\n  // hooks.createFromInputFallback(config);\n  return createInvalid(config);\n}\n\n// hooks.createFromInputFallback = deprecate(\n//     'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n//     'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n//     'discouraged and will be removed in an upcoming major release. Please refer to ' +\n//     'http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n//     function (config) {\n//         config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n//     }\n// );\n"]}

package/chronos/esm5/create/local.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { createLocalOrUTC } from './from-anything';
+import { isDate } from '../utils/type-checks';
+/**
+ * @param {?} input
+ * @param {?=} format
+ * @param {?=} localeKey
+ * @param {?=} strict
+ * @param {?=} isUTC
+ * @return {?}
+ */
+export function parseDate(input, format, localeKey, strict, isUTC) {
+    if (isDate(input)) {
+        return input;
+    }
+    var /** @type {?} */ config = createLocalOrUTC(input, format, localeKey, strict, isUTC);
+    return config._d;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9uZ3gtYm9vdHN0cmFwL2Nocm9ub3MvIiwic291cmNlcyI6WyJjcmVhdGUvbG9jYWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBR25ELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQzs7Ozs7Ozs7O0FBRTlDLE1BQU0sb0JBQW9CLEtBQWdCLEVBQUUsTUFBMEIsRUFDNUMsU0FBa0IsRUFBRSxNQUFnQixFQUFFLEtBQWU7SUFDN0UsRUFBRSxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNsQixNQUFNLENBQUMsS0FBSyxDQUFDO0tBQ2Q7SUFFRCxxQkFBTSxNQUFNLEdBQUcsZ0JBQWdCLENBQUMsS0FBSyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssQ0FBQyxDQUFDO0lBRXpFLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO0NBQ2xCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlTG9jYWxPclVUQyB9IGZyb20gJy4vZnJvbS1hbnl0aGluZyc7XG5pbXBvcnQgeyBEYXRlQXJyYXksIERhdGVPYmplY3QgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgeyBEYXRlSW5wdXQgfSBmcm9tICcuLi90ZXN0L2NoYWluJztcbmltcG9ydCB7IGlzRGF0ZSB9IGZyb20gJy4uL3V0aWxzL3R5cGUtY2hlY2tzJztcblxuZXhwb3J0IGZ1bmN0aW9uIHBhcnNlRGF0ZShpbnB1dDogRGF0ZUlucHV0LCBmb3JtYXQ/OiBzdHJpbmcgfCBzdHJpbmdbXSxcbiAgICAgICAgICAgICAgICAgICAgICAgICAgbG9jYWxlS2V5Pzogc3RyaW5nLCBzdHJpY3Q/OiBib29sZWFuLCBpc1VUQz86IGJvb2xlYW4pOiBEYXRlIHtcbiAgaWYgKGlzRGF0ZShpbnB1dCkpIHtcbiAgICByZXR1cm4gaW5wdXQ7XG4gIH1cblxuICBjb25zdCBjb25maWcgPSBjcmVhdGVMb2NhbE9yVVRDKGlucHV0LCBmb3JtYXQsIGxvY2FsZUtleSwgc3RyaWN0LCBpc1VUQyk7XG5cbiAgcmV0dXJuIGNvbmZpZy5fZDtcbn1cbiJdfQ==

package/chronos/esm5/create/parsing-flags.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @return {?}
+ */
+function defaultParsingFlags() {
+    // We need to deep clone this object.
+    return {
+        empty: false,
+        unusedTokens: [],
+        unusedInput: [],
+        overflow: -2,
+        charsLeftOver: 0,
+        nullInput: false,
+        invalidMonth: null,
+        invalidFormat: false,
+        userInvalidated: false,
+        iso: false,
+        parsedDateParts: [],
+        meridiem: null,
+        rfc2822: false,
+        weekdayMismatch: false
+    };
+}
+/**
+ * @param {?} config
+ * @return {?}
+ */
+export function getParsingFlags(config) {
+    if (config._pf == null) {
+        config._pf = defaultParsingFlags();
+    }
+    return config._pf;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2luZy1mbGFncy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL25neC1ib290c3RyYXAvY2hyb25vcy8iLCJzb3VyY2VzIjpbImNyZWF0ZS9wYXJzaW5nLWZsYWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7QUFFQTs7SUFFRSxNQUFNLENBQUM7UUFDTCxLQUFLLEVBQUUsS0FBSztRQUNaLFlBQVksRUFBRSxFQUFFO1FBQ2hCLFdBQVcsRUFBRSxFQUFFO1FBQ2YsUUFBUSxFQUFFLENBQUMsQ0FBQztRQUNaLGFBQWEsRUFBRSxDQUFDO1FBQ2hCLFNBQVMsRUFBRSxLQUFLO1FBQ2hCLFlBQVksRUFBRSxJQUFJO1FBQ2xCLGFBQWEsRUFBRSxLQUFLO1FBQ3BCLGVBQWUsRUFBRSxLQUFLO1FBQ3RCLEdBQUcsRUFBRSxLQUFLO1FBQ1YsZUFBZSxFQUFFLEVBQUU7UUFDbkIsUUFBUSxFQUFFLElBQUk7UUFDZCxPQUFPLEVBQUUsS0FBSztRQUNkLGVBQWUsRUFBRSxLQUFLO0tBQ3ZCLENBQUM7Q0FDSDs7Ozs7QUFFRCxNQUFNLDBCQUEwQixNQUF5QjtJQUN2RCxFQUFFLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxJQUFJLElBQUksQ0FBQyxDQUFDLENBQUM7UUFDdkIsTUFBTSxDQUFDLEdBQUcsR0FBRyxtQkFBbUIsRUFBRSxDQUFDO0tBQ3BDO0lBRUQsTUFBTSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUM7Q0FDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEYXRlUGFyc2luZ0NvbmZpZywgRGF0ZVBhcnNpbmdGbGFncyB9IGZyb20gJy4vcGFyc2luZy50eXBlcyc7XG5cbmZ1bmN0aW9uIGRlZmF1bHRQYXJzaW5nRmxhZ3MoKTogRGF0ZVBhcnNpbmdGbGFncyB7XG4gIC8vIFdlIG5lZWQgdG8gZGVlcCBjbG9uZSB0aGlzIG9iamVjdC5cbiAgcmV0dXJuIHtcbiAgICBlbXB0eTogZmFsc2UsXG4gICAgdW51c2VkVG9rZW5zOiBbXSxcbiAgICB1bnVzZWRJbnB1dDogW10sXG4gICAgb3ZlcmZsb3c6IC0yLFxuICAgIGNoYXJzTGVmdE92ZXI6IDAsXG4gICAgbnVsbElucHV0OiBmYWxzZSxcbiAgICBpbnZhbGlkTW9udGg6IG51bGwsXG4gICAgaW52YWxpZEZvcm1hdDogZmFsc2UsXG4gICAgdXNlckludmFsaWRhdGVkOiBmYWxzZSxcbiAgICBpc286IGZhbHNlLFxuICAgIHBhcnNlZERhdGVQYXJ0czogW10sXG4gICAgbWVyaWRpZW06IG51bGwsXG4gICAgcmZjMjgyMjogZmFsc2UsXG4gICAgd2Vla2RheU1pc21hdGNoOiBmYWxzZVxuICB9O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0UGFyc2luZ0ZsYWdzKGNvbmZpZzogRGF0ZVBhcnNpbmdDb25maWcpOiBEYXRlUGFyc2luZ0ZsYWdzIHtcbiAgaWYgKGNvbmZpZy5fcGYgPT0gbnVsbCkge1xuICAgIGNvbmZpZy5fcGYgPSBkZWZhdWx0UGFyc2luZ0ZsYWdzKCk7XG4gIH1cblxuICByZXR1cm4gY29uZmlnLl9wZjtcbn1cbiJdfQ==

package/chronos/esm5/create/parsing.types.js

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+/**
+ * @record
+ */
+export function DateParsingConfig() { }
+function DateParsingConfig_tsickle_Closure_declarations() {
+    /**
+     * date value
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._d;
+    /**
+     * DateArray [year, month, date, .....]
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._a;
+    /**
+     * date meridiem
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._meridiem;
+    /**
+     * is PM
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._isPm;
+    /** @type {?|undefined} */
+    DateParsingConfig.prototype._isUTC;
+    /** @type {?|undefined} */
+    DateParsingConfig.prototype._useUTC;
+    /**
+     * input to parse: could be string, number[], number, Date, object
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._i;
+    /**
+     * locale key, 'en' by default
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._l;
+    /**
+     * date locale obj
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._locale;
+    /**
+     * date format
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._f;
+    /**
+     * use strict parse format
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._strict;
+    /**
+     * add one day to result at the end of parsing
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._nextDay;
+    /**
+     * utc time offset
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._offset;
+    /**
+     * time zone
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._tzm;
+    /**
+     * is valid
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._isValid;
+    /**
+     * date parsing flags
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._pf;
+    /**
+     * week
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._w;
+    /** @type {?|undefined} */
+    DateParsingConfig.prototype._dayOfYear;
+    /**
+     * used in set offset
+     * @type {?|undefined}
+     */
+    DateParsingConfig.prototype._changeInProgress;
+    /** @type {?|undefined} */
+    DateParsingConfig.prototype._zoneDelta;
+}
+/**
+ * @record
+ */
+export function DateParsingFlags() { }
+function DateParsingFlags_tsickle_Closure_declarations() {
+    /** @type {?|undefined} */
+    DateParsingFlags.prototype._overflowDayOfYear;
+    /** @type {?|undefined} */
+    DateParsingFlags.prototype._overflowWeeks;
+    /** @type {?|undefined} */
+    DateParsingFlags.prototype._overflowWeekday;
+    /** @type {?|undefined} */
+    DateParsingFlags.prototype.score;
+    /** @type {?|undefined} */
+    DateParsingFlags.prototype.bigHour;
+    /** @type {?} */
+    DateParsingFlags.prototype.empty;
+    /** @type {?} */
+    DateParsingFlags.prototype.unusedTokens;
+    /** @type {?} */
+    DateParsingFlags.prototype.unusedInput;
+    /** @type {?} */
+    DateParsingFlags.prototype.overflow;
+    /** @type {?} */
+    DateParsingFlags.prototype.charsLeftOver;
+    /** @type {?} */
+    DateParsingFlags.prototype.nullInput;
+    /** @type {?} */
+    DateParsingFlags.prototype.invalidMonth;
+    /** @type {?|undefined} */
+    DateParsingFlags.prototype.invalidWeekday;
+    /** @type {?} */
+    DateParsingFlags.prototype.invalidFormat;
+    /** @type {?} */
+    DateParsingFlags.prototype.userInvalidated;
+    /** @type {?} */
+    DateParsingFlags.prototype.iso;
+    /** @type {?} */
+    DateParsingFlags.prototype.parsedDateParts;
+    /** @type {?} */
+    DateParsingFlags.prototype.meridiem;
+    /** @type {?} */
+    DateParsingFlags.prototype.rfc2822;
+    /** @type {?} */
+    DateParsingFlags.prototype.weekdayMismatch;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/chronos/esm5/create/valid.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { getParsingFlags } from './parsing-flags';
+/**
+ * @param {?} config
+ * @return {?}
+ */
+export function isValid(config) {
+    if (config._isValid == null) {
+        var /** @type {?} */ flags = getParsingFlags(config);
+        var /** @type {?} */ parsedParts = Array.prototype.some.call(flags.parsedDateParts, function (i) {
+            return i != null;
+        });
+        var /** @type {?} */ isNowValid = !isNaN(config._d && config._d.getTime()) &&
+            flags.overflow < 0 &&
+            !flags.empty &&
+            !flags.invalidMonth &&
+            !flags.invalidWeekday &&
+            !flags.weekdayMismatch &&
+            !flags.nullInput &&
+            !flags.invalidFormat &&
+            !flags.userInvalidated &&
+            (!flags.meridiem || (flags.meridiem && parsedParts));
+        if (config._strict) {
+            isNowValid = isNowValid &&
+                flags.charsLeftOver === 0 &&
+                flags.unusedTokens.length === 0 &&
+                flags.bigHour === undefined;
+        }
+        if (Object.isFrozen == null || !Object.isFrozen(config)) {
+            config._isValid = isNowValid;
+        }
+        else {
+            return isNowValid;
+        }
+    }
+    return config._isValid;
+}
+/**
+ * @param {?} config
+ * @param {?=} flags
+ * @return {?}
+ */
+export function createInvalid(config, flags) {
+    config._d = new Date(NaN);
+    Object.assign(getParsingFlags(config), flags || { userInvalidated: true });
+    return config;
+}
+/**
+ * @param {?} config
+ * @return {?}
+ */
+export function markInvalid(config) {
+    config._isValid = false;
+    return config;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/chronos/esm5/duration/bubble.js

@@ -0,0 +1,64 @@
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+import { absFloor } from '../utils';
+import { absCeil } from '../utils/abs-ceil';
+/**
+ * @param {?} dur
+ * @return {?}
+ */
+export function bubble(dur) {
+    var /** @type {?} */ milliseconds = dur._milliseconds;
+    var /** @type {?} */ days = dur._days;
+    var /** @type {?} */ months = dur._months;
+    var /** @type {?} */ data = dur._data;
+    // if we have a mix of positive and negative values, bubble down first
+    // check: https://github.com/moment/moment/issues/2166
+    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||
+        (milliseconds <= 0 && days <= 0 && months <= 0))) {
+        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;
+        days = 0;
+        months = 0;
+    }
+    // The following code bubbles up values, see the tests for
+    // examples of what that means.
+    data.milliseconds = milliseconds % 1000;
+    var /** @type {?} */ seconds = absFloor(milliseconds / 1000);
+    data.seconds = seconds % 60;
+    var /** @type {?} */ minutes = absFloor(seconds / 60);
+    data.minutes = minutes % 60;
+    var /** @type {?} */ hours = absFloor(minutes / 60);
+    data.hours = hours % 24;
+    days += absFloor(hours / 24);
+    // convert days to months
+    var /** @type {?} */ monthsFromDays = absFloor(daysToMonths(days));
+    months += monthsFromDays;
+    days -= absCeil(monthsToDays(monthsFromDays));
+    // 12 months -> 1 year
+    var /** @type {?} */ years = absFloor(months / 12);
+    months %= 12;
+    data.day = days;
+    data.month = months;
+    data.year = years;
+    return dur;
+}
+/**
+ * @param {?} day
+ * @return {?}
+ */
+export function daysToMonths(day) {
+    // 400 years have 146097 days (taking into account leap year rules)
+    // 400 years have 12 months === 4800
+    return day * 4800 / 146097;
+}
+/**
+ * @param {?} month
+ * @return {?}
+ */
+export function monthsToDays(month) {
+    // the reverse of daysToMonths
+    return month * 146097 / 4800;
+}
+
+//# sourceMappingURL=data:application/json;base64,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