@mis-wis/common 0.1.6 → 0.1.7

package/esm2020/src/lib/components/datepicker/chronos/units/month.mjs

@@ -0,0 +1,63 @@
+import { addFormatToken } from '../format/format';
+import { isLeapYear } from './year';
+import { mod } from '../utils';
+import { getMonth } from '../utils/date-getters';
+import { addRegexToken, match1to2, match2 } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { MONTH } from './constants';
+import { toInt } from '../utils/type-checks';
+import { addUnitPriority } from './priorities';
+import { addUnitAlias } from './aliases';
+import { getParsingFlags } from '../create/parsing-flags';
+// todo: this is duplicate, source in date-getters.ts
+export function daysInMonth(year, month) {
+    if (isNaN(year) || isNaN(month)) {
+        return NaN;
+    }
+    const modMonth = mod(month, 12);
+    const _year = year + (month - modMonth) / 12;
+    return modMonth === 1
+        ? isLeapYear(_year) ? 29 : 28
+        : (31 - modMonth % 7 % 2);
+}
+export function initMonth() {
+    // FORMATTING
+    addFormatToken('M', ['MM', 2, false], 'Mo', function (date, opts) {
+        return (getMonth(date, opts.isUTC) + 1).toString(10);
+    });
+    addFormatToken('MMM', null, null, function (date, opts) {
+        return opts.locale.monthsShort(date, opts.format, opts.isUTC);
+    });
+    addFormatToken('MMMM', null, null, function (date, opts) {
+        return opts.locale.months(date, opts.format, opts.isUTC);
+    });
+    // ALIASES
+    addUnitAlias('month', 'M');
+    // PRIORITY
+    addUnitPriority('month', 8);
+    // PARSING
+    addRegexToken('M', match1to2);
+    addRegexToken('MM', match1to2, match2);
+    addRegexToken('MMM', function (isStrict, locale) {
+        return locale.monthsShortRegex(isStrict);
+    });
+    addRegexToken('MMMM', function (isStrict, locale) {
+        return locale.monthsRegex(isStrict);
+    });
+    addParseToken(['M', 'MM'], function (input, array, config) {
+        array[MONTH] = toInt(input) - 1;
+        return config;
+    });
+    addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
+        const month = config._locale.monthsParse(input, token, config._strict);
+        // if we didn't find a month name, mark the date as invalid.
+        if (month != null) {
+            array[MONTH] = month;
+        }
+        else {
+            getParsingFlags(config).invalidMonth = !!input;
+        }
+        return config;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/components/datepicker/chronos/units/offset.mjs

@@ -0,0 +1,210 @@
+// tslint:disable:no-bitwise max-line-length
+// FORMATTING
+import { addFormatToken } from '../format/format';
+import { zeroFill } from '../utils/zero-fill';
+import { isNumber, isString, toInt } from '../utils/type-checks';
+import { addRegexToken, matchOffset, matchShortOffset } from '../parse/regex';
+import { add } from '../moment/add-subtract';
+import { addParseToken } from '../parse/token';
+import { cloneDate } from '../create/clone';
+import { setMonth } from '../utils/date-setters';
+function addOffsetFormatToken(token, separator) {
+    addFormatToken(token, null, null, function (date, config) {
+        let offset = getUTCOffset(date, { _isUTC: config.isUTC, _offset: config.offset });
+        let sign = '+';
+        if (offset < 0) {
+            offset = -offset;
+            sign = '-';
+        }
+        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);
+    });
+}
+export function initOffset() {
+    addOffsetFormatToken('Z', ':');
+    addOffsetFormatToken('ZZ', '');
+    // PARSING
+    addRegexToken('Z', matchShortOffset);
+    addRegexToken('ZZ', matchShortOffset);
+    addParseToken(['Z', 'ZZ'], function (input, array, config) {
+        config._useUTC = true;
+        config._tzm = offsetFromString(matchShortOffset, input);
+        return config;
+    });
+}
+// HELPERS
+// timezone chunker
+// '+10:00' > ['10',  '00']
+// '-1530'  > ['-15', '30']
+const chunkOffset = /([\+\-]|\d\d)/gi;
+function offsetFromString(matcher, str) {
+    const matches = (str || '').match(matcher);
+    if (matches === null) {
+        return null;
+    }
+    const chunk = matches[matches.length - 1];
+    const parts = chunk.match(chunkOffset) || ['-', '0', '0'];
+    const minutes = parseInt(parts[1], 10) * 60 + toInt(parts[2]);
+    const _min = parts[0] === '+' ? minutes : -minutes;
+    return minutes === 0 ? 0 : _min;
+}
+// Return a moment from input, that is local/utc/zone equivalent to model.
+export function cloneWithOffset(input, date, config = {}) {
+    if (!config._isUTC) {
+        return input;
+    }
+    const res = cloneDate(date);
+    // todo: input._d - res._d + ((res._offset || 0) - (input._offset || 0))*60000
+    const offsetDiff = (config._offset || 0) * 60000;
+    const diff = input.valueOf() - res.valueOf() + offsetDiff;
+    // Use low-level api, because this fn is low-level api.
+    res.setTime(res.valueOf() + diff);
+    // todo: add timezone handling
+    // hooks.updateOffset(res, false);
+    return res;
+}
+export function getDateOffset(date) {
+    // On Firefox.24 Date#getTimezoneOffset returns a floating point.
+    // https://github.com/moment/moment/pull/1871
+    return -Math.round(date.getTimezoneOffset() / 15) * 15;
+}
+// HOOKS
+// This function will be called whenever a moment is mutated.
+// It is intended to keep the offset in sync with the timezone.
+// todo: it's from moment timezones
+// hooks.updateOffset = function () {
+// };
+// MOMENTS
+// keepLocalTime = true means only change the timezone, without
+// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
+// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
+// +0200, so we adjust the time as needed, to be valid.
+//
+// Keeping the time actually adds/subtracts (one hour)
+// from the actual represented time. That is why we call updateOffset
+// a second time. In case it wants us to change the offset again
+// _changeInProgress == true case, then we have to adjust, because
+// there is no such time in the given timezone.
+export function getUTCOffset(date, config = {}) {
+    const _offset = config._offset || 0;
+    return config._isUTC ? _offset : getDateOffset(date);
+}
+export function setUTCOffset(date, input, keepLocalTime, keepMinutes, config = {}) {
+    const offset = config._offset || 0;
+    let localAdjust;
+    let _input = input;
+    let _date = date;
+    if (isString(_input)) {
+        _input = offsetFromString(matchShortOffset, _input);
+        if (_input === null) {
+            return _date;
+        }
+    }
+    else if (isNumber(_input) && Math.abs(_input) < 16 && !keepMinutes) {
+        _input = _input * 60;
+    }
+    if (!config._isUTC && keepLocalTime) {
+        localAdjust = getDateOffset(_date);
+    }
+    config._offset = _input;
+    config._isUTC = true;
+    if (localAdjust != null) {
+        _date = add(_date, localAdjust, 'minutes');
+    }
+    if (offset !== _input) {
+        if (!keepLocalTime || config._changeInProgress) {
+            _date = add(_date, _input - offset, 'minutes', config._isUTC);
+            // addSubtract(this, createDuration(_input - offset, 'm'), 1, false);
+        }
+        else if (!config._changeInProgress) {
+            config._changeInProgress = true;
+            // todo: add timezone handling
+            // hooks.updateOffset(this, true);
+            config._changeInProgress = null;
+        }
+    }
+    return _date;
+}
+/*
+export function getSetZone(input, keepLocalTime) {
+  if (input != null) {
+    if (typeof input !== 'string') {
+      input = -input;
+    }
+
+    this.utcOffset(input, keepLocalTime);
+
+    return this;
+  } else {
+    return -this.utcOffset();
+  }
+}
+*/
+export function setOffsetToUTC(date, keepLocalTime) {
+    return setUTCOffset(date, 0, keepLocalTime);
+}
+export function isDaylightSavingTime(date) {
+    return (getUTCOffset(date) > getUTCOffset(setMonth(cloneDate(date), 0))
+        || getUTCOffset(date) > getUTCOffset(setMonth(cloneDate(date), 5)));
+}
+/*export function setOffsetToLocal(date: Date, isUTC?: boolean, keepLocalTime?: boolean) {
+  if (this._isUTC) {
+    this.utcOffset(0, keepLocalTime);
+    this._isUTC = false;
+
+    if (keepLocalTime) {
+      this.subtract(getDateOffset(this), 'm');
+    }
+  }
+  return this;
+}*/
+export function setOffsetToParsedOffset(date, input, config = {}) {
+    if (config._tzm != null) {
+        return setUTCOffset(date, config._tzm, false, true, config);
+    }
+    if (isString(input)) {
+        const tZone = offsetFromString(matchOffset, input);
+        if (tZone != null) {
+            return setUTCOffset(date, tZone, false, false, config);
+        }
+        return setUTCOffset(date, 0, true, false, config);
+    }
+    return date;
+}
+export function hasAlignedHourOffset(date, input) {
+    const _input = input ? getUTCOffset(input, { _isUTC: false }) : 0;
+    return (getUTCOffset(date) - _input) % 60 === 0;
+}
+// DEPRECATED
+/*export function isDaylightSavingTimeShifted() {
+  if (!isUndefined(this._isDSTShifted)) {
+    return this._isDSTShifted;
+  }
+
+  const c = {};
+
+  copyConfig(c, this);
+  c = prepareConfig(c);
+
+  if (c._a) {
+    const other = c._isUTC ? createUTC(c._a) : createLocal(c._a);
+    this._isDSTShifted = this.isValid() &&
+      compareArrays(c._a, other.toArray()) > 0;
+  } else {
+    this._isDSTShifted = false;
+  }
+
+  return this._isDSTShifted;
+}*/
+// in Khronos
+/*export function isLocal() {
+  return this.isValid() ? !this._isUTC : false;
+}
+
+export function isUtcOffset() {
+  return this.isValid() ? this._isUTC : false;
+}
+
+export function isUtc() {
+  return this.isValid() ? this._isUTC && this._offset === 0 : false;
+}*/
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"offset.js","sourceRoot":"","sources":["../../../../../../../../../libraries/wis-common/src/lib/components/datepicker/chronos/units/offset.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:no-bitwise max-line-length\n// FORMATTING\n\nimport { addFormatToken } from '../format/format';\nimport { zeroFill } from '../utils/zero-fill';\nimport { DateParsingConfig } from '../create/parsing.types';\nimport { isNumber, isString, toInt } from '../utils/type-checks';\nimport { addRegexToken, matchOffset, matchShortOffset } from '../parse/regex';\nimport { add } from '../moment/add-subtract';\nimport { addParseToken } from '../parse/token';\nimport { DateArray } from '../types';\nimport { cloneDate } from '../create/clone';\nimport { setMonth } from '../utils/date-setters';\n\nfunction addOffsetFormatToken(token: string, separator: string): void {\n  addFormatToken(token, null, null, function (date: Date, config): string {\n    let offset = getUTCOffset(date, {_isUTC: config.isUTC, _offset: config.offset});\n    let sign = '+';\n    if (offset < 0) {\n      offset = -offset;\n      sign = '-';\n    }\n\n    return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);\n  });\n}\n\nexport function initOffset() {\n  addOffsetFormatToken('Z', ':');\n  addOffsetFormatToken('ZZ', '');\n\n// PARSING\n\n  addRegexToken('Z', matchShortOffset);\n  addRegexToken('ZZ', matchShortOffset);\n  addParseToken(['Z', 'ZZ'], function(input: string, array: DateArray, config: DateParsingConfig): DateParsingConfig {\n    config._useUTC = true;\n    config._tzm = offsetFromString(matchShortOffset, input);\n\n    return config;\n  });\n}\n\n// HELPERS\n\n// timezone chunker\n// '+10:00' > ['10',  '00']\n// '-1530'  > ['-15', '30']\nconst chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\nfunction offsetFromString(matcher: RegExp, str: string): number {\n  const matches = (str || '').match(matcher);\n\n  if (matches === null) {\n    return null;\n  }\n\n  const chunk = matches[matches.length - 1];\n  const parts = chunk.match(chunkOffset) || ['-', '0', '0'];\n  const minutes = parseInt(parts[1], 10) * 60 + toInt(parts[2]);\n  const _min = parts[0] === '+' ? minutes : -minutes;\n\n  return minutes === 0 ? 0 : _min;\n}\n\n// Return a moment from input, that is local/utc/zone equivalent to model.\nexport function cloneWithOffset(input: Date, date: Date,\n                                config: DateParsingConfig = {}): Date {\n  if (!config._isUTC) {\n    return input;\n  }\n\n  const res = cloneDate(date);\n  // todo: input._d - res._d + ((res._offset || 0) - (input._offset || 0))*60000\n  const offsetDiff = (config._offset || 0) * 60000;\n  const diff = input.valueOf() - res.valueOf() + offsetDiff;\n  // Use low-level api, because this fn is low-level api.\n  res.setTime(res.valueOf() + diff);\n  // todo: add timezone handling\n  // hooks.updateOffset(res, false);\n\n  return res;\n}\n\nexport function getDateOffset(date: Date): number {\n  // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n  // https://github.com/moment/moment/pull/1871\n  return -Math.round(date.getTimezoneOffset() / 15) * 15;\n}\n\n// HOOKS\n\n// This function will be called whenever a moment is mutated.\n// It is intended to keep the offset in sync with the timezone.\n// todo: it's from moment timezones\n// hooks.updateOffset = function () {\n// };\n\n// MOMENTS\n\n// keepLocalTime = true means only change the timezone, without\n// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n// +0200, so we adjust the time as needed, to be valid.\n//\n// Keeping the time actually adds/subtracts (one hour)\n// from the actual represented time. That is why we call updateOffset\n// a second time. In case it wants us to change the offset again\n// _changeInProgress == true case, then we have to adjust, because\n// there is no such time in the given timezone.\nexport function getUTCOffset(date: Date, config: DateParsingConfig = {}): number {\n  const _offset = config._offset || 0;\n\n  return config._isUTC ? _offset : getDateOffset(date);\n}\n\nexport function setUTCOffset(date: Date, input: number | string, keepLocalTime?: boolean, keepMinutes?: boolean, config: DateParsingConfig = {}): Date {\n  const offset = config._offset || 0;\n  let localAdjust;\n  let _input = input;\n  let _date = date;\n\n  if (isString(_input)) {\n    _input = offsetFromString(matchShortOffset, _input);\n    if (_input === null) {\n      return _date;\n    }\n  } else if (isNumber(_input) && Math.abs(_input) < 16 && !keepMinutes) {\n    _input = _input * 60;\n  }\n\n  if (!config._isUTC && keepLocalTime) {\n    localAdjust = getDateOffset(_date);\n  }\n  config._offset = _input;\n  config._isUTC = true;\n  if (localAdjust != null) {\n    _date = add(_date, localAdjust, 'minutes');\n  }\n  if (offset !== _input) {\n    if (!keepLocalTime || config._changeInProgress) {\n      _date = add(_date, _input - offset, 'minutes', config._isUTC);\n      // addSubtract(this, createDuration(_input - offset, 'm'), 1, false);\n    } else if (!config._changeInProgress) {\n      config._changeInProgress = true;\n      // todo: add timezone handling\n      // hooks.updateOffset(this, true);\n      config._changeInProgress = null;\n    }\n  }\n\n  return _date;\n}\n\n/*\nexport function getSetZone(input, keepLocalTime) {\n  if (input != null) {\n    if (typeof input !== 'string') {\n      input = -input;\n    }\n\n    this.utcOffset(input, keepLocalTime);\n\n    return this;\n  } else {\n    return -this.utcOffset();\n  }\n}\n*/\n\nexport function setOffsetToUTC(date: Date, keepLocalTime?: boolean): Date {\n  return setUTCOffset(date, 0, keepLocalTime);\n}\n\nexport function isDaylightSavingTime(date: Date): boolean {\n\n  return (getUTCOffset(date) > getUTCOffset(setMonth(cloneDate(date), 0))\n    || getUTCOffset(date) > getUTCOffset(setMonth(cloneDate(date), 5)));\n}\n\n/*export function setOffsetToLocal(date: Date, isUTC?: boolean, keepLocalTime?: boolean) {\n  if (this._isUTC) {\n    this.utcOffset(0, keepLocalTime);\n    this._isUTC = false;\n\n    if (keepLocalTime) {\n      this.subtract(getDateOffset(this), 'm');\n    }\n  }\n  return this;\n}*/\n\nexport function setOffsetToParsedOffset(date: Date, input: string, config: DateParsingConfig = {}): Date {\n  if (config._tzm != null) {\n    return setUTCOffset(date, config._tzm, false, true, config);\n  }\n\n  if (isString(input)) {\n    const tZone = offsetFromString(matchOffset, input);\n    if (tZone != null) {\n      return setUTCOffset(date, tZone, false, false, config);\n    }\n\n    return setUTCOffset(date, 0, true, false, config);\n  }\n\n  return date;\n}\n\nexport function hasAlignedHourOffset(date: Date, input?: Date) {\n  const _input = input ? getUTCOffset(input, { _isUTC: false }) : 0;\n\n  return (getUTCOffset(date) - _input) % 60 === 0;\n}\n\n\n// DEPRECATED\n/*export function isDaylightSavingTimeShifted() {\n  if (!isUndefined(this._isDSTShifted)) {\n    return this._isDSTShifted;\n  }\n\n  const c = {};\n\n  copyConfig(c, this);\n  c = prepareConfig(c);\n\n  if (c._a) {\n    const other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n    this._isDSTShifted = this.isValid() &&\n      compareArrays(c._a, other.toArray()) > 0;\n  } else {\n    this._isDSTShifted = false;\n  }\n\n  return this._isDSTShifted;\n}*/\n\n// in Khronos\n/*export function isLocal() {\n  return this.isValid() ? !this._isUTC : false;\n}\n\nexport function isUtcOffset() {\n  return this.isValid() ? this._isUTC : false;\n}\n\nexport function isUtc() {\n  return this.isValid() ? this._isUTC && this._offset === 0 : false;\n}*/\n"]}

package/esm2020/src/lib/components/datepicker/chronos/units/priorities.mjs

@@ -0,0 +1,21 @@
+const priorities = {};
+export function addUnitPriority(unit, priority) {
+    priorities[unit] = priority;
+}
+/*
+export function getPrioritizedUnits(unitsObj) {
+  const units = [];
+  let unit;
+  for (unit in unitsObj) {
+    if (unitsObj.hasOwnProperty(unit)) {
+      units.push({ unit, priority: priorities[unit] });
+    }
+  }
+  units.sort(function (a, b) {
+    return a.priority - b.priority;
+  });
+
+  return units;
+}
+*/
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJpb3JpdGllcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnJhcmllcy93aXMtY29tbW9uL3NyYy9saWIvY29tcG9uZW50cy9kYXRlcGlja2VyL2Nocm9ub3MvdW5pdHMvcHJpb3JpdGllcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLFVBQVUsR0FBNEIsRUFBRSxDQUFDO0FBRS9DLE1BQU0sVUFBVSxlQUFlLENBQUMsSUFBWSxFQUFFLFFBQWdCO0lBQzVELFVBQVUsQ0FBQyxJQUFJLENBQUMsR0FBRyxRQUFRLENBQUM7QUFDOUIsQ0FBQztBQUVEOzs7Ozs7Ozs7Ozs7Ozs7RUFlRSIsInNvdXJjZXNDb250ZW50IjpbImNvbnN0IHByaW9yaXRpZXM6IHtba2V5OiBzdHJpbmddOiBudW1iZXJ9ID0ge307XG5cbmV4cG9ydCBmdW5jdGlvbiBhZGRVbml0UHJpb3JpdHkodW5pdDogc3RyaW5nLCBwcmlvcml0eTogbnVtYmVyKTogdm9pZCB7XG4gIHByaW9yaXRpZXNbdW5pdF0gPSBwcmlvcml0eTtcbn1cblxuLypcbmV4cG9ydCBmdW5jdGlvbiBnZXRQcmlvcml0aXplZFVuaXRzKHVuaXRzT2JqKSB7XG4gIGNvbnN0IHVuaXRzID0gW107XG4gIGxldCB1bml0O1xuICBmb3IgKHVuaXQgaW4gdW5pdHNPYmopIHtcbiAgICBpZiAodW5pdHNPYmouaGFzT3duUHJvcGVydHkodW5pdCkpIHtcbiAgICAgIHVuaXRzLnB1c2goeyB1bml0LCBwcmlvcml0eTogcHJpb3JpdGllc1t1bml0XSB9KTtcbiAgICB9XG4gIH1cbiAgdW5pdHMuc29ydChmdW5jdGlvbiAoYSwgYikge1xuICAgIHJldHVybiBhLnByaW9yaXR5IC0gYi5wcmlvcml0eTtcbiAgfSk7XG5cbiAgcmV0dXJuIHVuaXRzO1xufVxuKi9cbiJdfQ==

package/esm2020/src/lib/components/datepicker/chronos/units/quarter.mjs

@@ -0,0 +1,39 @@
+import { addFormatToken } from '../format/format';
+import { addRegexToken, match1 } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { MONTH } from './constants';
+import { toInt } from '../utils/type-checks';
+import { getMonth } from '../utils/date-getters';
+import { addUnitPriority } from './priorities';
+import { addUnitAlias } from './aliases';
+import { setMonth } from '../utils/date-setters';
+export function initQuarter() {
+    // FORMATTING
+    addFormatToken('Q', null, 'Qo', function (date, opts) {
+        return getQuarter(date, opts.isUTC)
+            .toString(10);
+    });
+    // ALIASES
+    addUnitAlias('quarter', 'Q');
+    // PRIORITY
+    addUnitPriority('quarter', 7);
+    // PARSING
+    addRegexToken('Q', match1);
+    addParseToken('Q', function (input, array, config) {
+        array[MONTH] = (toInt(input) - 1) * 3;
+        return config;
+    });
+}
+// MOMENTS
+export function getQuarter(date, isUTC = false) {
+    return Math.ceil((getMonth(date, isUTC) + 1) / 3);
+}
+export function setQuarter(date, quarter, isUTC) {
+    return setMonth(date, (quarter - 1) * 3 + getMonth(date, isUTC) % 3, isUTC);
+}
+// export function getSetQuarter(input) {
+//   return input == null
+//     ? Math.ceil((this.month() + 1) / 3)
+//     : this.month((input - 1) * 3 + this.month() % 3);
+// }
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/components/datepicker/chronos/units/second.mjs

@@ -0,0 +1,23 @@
+import { addFormatToken } from '../format/format';
+import { getSeconds } from '../utils/date-getters';
+import { addRegexToken, match1to2, match2 } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { SECOND } from './constants';
+import { addUnitAlias } from './aliases';
+import { addUnitPriority } from './priorities';
+export function initSecond() {
+    // FORMATTING
+    addFormatToken('s', ['ss', 2, false], null, function (date, opts) {
+        return getSeconds(date, opts.isUTC)
+            .toString(10);
+    });
+    // ALIASES
+    addUnitAlias('second', 's');
+    // PRIORITY
+    addUnitPriority('second', 15);
+    // PARSING
+    addRegexToken('s', match1to2);
+    addRegexToken('ss', match1to2, match2);
+    addParseToken(['s', 'ss'], SECOND);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/components/datepicker/chronos/units/timestamp.mjs

@@ -0,0 +1,28 @@
+import { addFormatToken } from '../format/format';
+import { unix } from '../utils/date-getters';
+import { addRegexToken, matchSigned, matchTimestamp } from '../parse/regex';
+import { addParseToken } from '../parse/token';
+import { toInt } from '../utils/type-checks';
+export function initTimestamp() {
+    // FORMATTING
+    addFormatToken('X', null, null, function (date) {
+        return unix(date)
+            .toString(10);
+    });
+    addFormatToken('x', null, null, function (date) {
+        return date.valueOf()
+            .toString(10);
+    });
+    // PARSING
+    addRegexToken('x', matchSigned);
+    addRegexToken('X', matchTimestamp);
+    addParseToken('X', function (input, array, config) {
+        config._d = new Date(parseFloat(input) * 1000);
+        return config;
+    });
+    addParseToken('x', function (input, array, config) {
+        config._d = new Date(toInt(input));
+        return config;
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/components/datepicker/chronos/units/timezone.mjs

@@ -0,0 +1,19 @@
+import { addFormatToken } from '../format/format';
+// todo: add support for timezones
+export function initTimezone() {
+    // FORMATTING
+    addFormatToken('z', null, null, function (date, opts) {
+        return opts.isUTC ? 'UTC' : '';
+    });
+    addFormatToken('zz', null, null, function (date, opts) {
+        return opts.isUTC ? 'Coordinated Universal Time' : '';
+    });
+}
+// MOMENTS
+export function getZoneAbbr(isUTC) {
+    return isUTC ? 'UTC' : '';
+}
+export function getZoneName(isUTC) {
+    return isUTC ? 'Coordinated Universal Time' : '';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/src/lib/components/datepicker/chronos/units/week-calendar-utils.mjs

@@ -0,0 +1,70 @@
+/**
+ *
+ * @param {number} year
+ * @param {number} dow - start-of-first-week
+ * @param {number} doy - start-of-year
+ * @returns {number}
+ */
+import { createUTCDate } from '../create/date-from-array';
+import { daysInYear } from './year';
+import { getDayOfYear } from './day-of-year';
+import { getFullYear } from '../utils/date-getters';
+function firstWeekOffset(year, dow, doy) {
+    // first-week day -- which january is always in the first week (4 for iso, 1 for other)
+    const fwd = dow - doy + 7;
+    // first-week day local weekday -- which local weekday is fwd
+    const fwdlw = (createUTCDate(year, 0, fwd).getUTCDay() - dow + 7) % 7;
+    return -fwdlw + fwd - 1;
+}
+// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
+export function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
+    const localWeekday = (7 + weekday - dow) % 7;
+    const weekOffset = firstWeekOffset(year, dow, doy);
+    const dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset;
+    let resYear;
+    let resDayOfYear;
+    if (dayOfYear <= 0) {
+        resYear = year - 1;
+        resDayOfYear = daysInYear(resYear) + dayOfYear;
+    }
+    else if (dayOfYear > daysInYear(year)) {
+        resYear = year + 1;
+        resDayOfYear = dayOfYear - daysInYear(year);
+    }
+    else {
+        resYear = year;
+        resDayOfYear = dayOfYear;
+    }
+    return {
+        year: resYear,
+        dayOfYear: resDayOfYear
+    };
+}
+export function weekOfYear(date, dow, doy, isUTC) {
+    const weekOffset = firstWeekOffset(getFullYear(date, isUTC), dow, doy);
+    const week = Math.floor((getDayOfYear(date, isUTC) - weekOffset - 1) / 7) + 1;
+    let resWeek;
+    let resYear;
+    if (week < 1) {
+        resYear = getFullYear(date, isUTC) - 1;
+        resWeek = week + weeksInYear(resYear, dow, doy);
+    }
+    else if (week > weeksInYear(getFullYear(date, isUTC), dow, doy)) {
+        resWeek = week - weeksInYear(getFullYear(date, isUTC), dow, doy);
+        resYear = getFullYear(date, isUTC) + 1;
+    }
+    else {
+        resYear = getFullYear(date, isUTC);
+        resWeek = week;
+    }
+    return {
+        week: resWeek,
+        year: resYear
+    };
+}
+export function weeksInYear(year, dow, doy) {
+    const weekOffset = firstWeekOffset(year, dow, doy);
+    const weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
+    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
+}
+//# sourceMappingURL=data:application/json;base64,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