@esri/calcite-components 2.8.2 → 2.8.4

package/dist/esm/calcite-input-time-picker.calcite-time-picker-95823100.js

@@ -0,0 +1,2929 @@
+/*!
+ * All material copyright ESRI, All Rights Reserved, unless otherwise specified.
+ * See https://github.com/Esri/calcite-design-system/blob/main/LICENSE.md for details.
+ * v2.8.4
+ */
+import { r as registerInstance, c as createEvent, h, H as Host, g as getElement } from './index-6078fda3.js';
+import { s as submitForm, c as connectForm, d as disconnectForm, H as HiddenFormInputSlot } from './form-83797097.js';
+import { g as guid } from './guid-2dee4ae7.js';
+import { c as connectInteractive, d as disconnectInteractive, u as updateHostInteraction, I as InteractiveContainer } from './interactive-635e4dd6.js';
+import { n as numberKeys } from './key-260e12d1.js';
+import { c as connectLabel, d as disconnectLabel, g as getLabelText } from './label-f401783f.js';
+import { c as componentFocusable, s as setUpLoadableComponent, a as setComponentLoaded } from './loadable-b3030183.js';
+import { n as numberStringFormatter, e as getDateTimeFormat, i as isValidNumber, b as getSupportedNumberingSystem, g as getSupportedLocale, c as connectLocalized, d as disconnectLocalized } from './locale-51d3ea2b.js';
+import { d as deactivateFocusTrap, a as activateFocusTrap, c as connectFocusTrap } from './focusTrapComponent-314f1b8f.js';
+import { d as decimalPlaces, g as getDecimals } from './math-4d056a0f.js';
+import { c as connectMessages, s as setUpMessages, d as disconnectMessages, u as updateMessages } from './t9n-c4c5a4b3.js';
+import { o as onToggleOpenCloseComponent } from './openCloseComponent-e21983e7.js';
+import { g as getIconScale } from './component-d31bcac1.js';
+import { V as Validation } from './Validation-4a0d6e90.js';
+
+var SECONDS_A_MINUTE = 60;
+var SECONDS_A_HOUR = SECONDS_A_MINUTE * 60;
+var SECONDS_A_DAY = SECONDS_A_HOUR * 24;
+var SECONDS_A_WEEK = SECONDS_A_DAY * 7;
+var MILLISECONDS_A_SECOND = 1e3;
+var MILLISECONDS_A_MINUTE = SECONDS_A_MINUTE * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_HOUR = SECONDS_A_HOUR * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_DAY = SECONDS_A_DAY * MILLISECONDS_A_SECOND;
+var MILLISECONDS_A_WEEK = SECONDS_A_WEEK * MILLISECONDS_A_SECOND; // English locales
+
+var MS = 'millisecond';
+var S = 'second';
+var MIN = 'minute';
+var H = 'hour';
+var D = 'day';
+var W = 'week';
+var M = 'month';
+var Q = 'quarter';
+var Y = 'year';
+var DATE = 'date';
+var FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ';
+var INVALID_DATE_STRING = 'Invalid Date'; // regex
+
+var REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+var REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
+
+// English [en]
+// We don't need weekdaysShort, weekdaysMin, monthsShort in en.js locale
+const en = {
+  name: 'en',
+  weekdays: 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_'),
+  months: 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_'),
+  ordinal: function ordinal(n) {
+    var s = ['th', 'st', 'nd', 'rd'];
+    var v = n % 100;
+    return "[" + n + (s[(v - 20) % 10] || s[v] || s[0]) + "]";
+  }
+};
+
+const en$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  'default': en
+});
+
+var padStart = function padStart(string, length, pad) {
+  var s = String(string);
+  if (!s || s.length >= length) return string;
+  return "" + Array(length + 1 - s.length).join(pad) + string;
+};
+
+var padZoneStr = function padZoneStr(instance) {
+  var negMinutes = -instance.utcOffset();
+  var minutes = Math.abs(negMinutes);
+  var hourOffset = Math.floor(minutes / 60);
+  var minuteOffset = minutes % 60;
+  return "" + (negMinutes <= 0 ? '+' : '-') + padStart(hourOffset, 2, '0') + ":" + padStart(minuteOffset, 2, '0');
+};
+
+var monthDiff = function monthDiff(a, b) {
+  // function from moment.js in order to keep the same result
+  if (a.date() < b.date()) return -monthDiff(b, a);
+  var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month());
+  var anchor = a.clone().add(wholeMonthDiff, M);
+  var c = b - anchor < 0;
+  var anchor2 = a.clone().add(wholeMonthDiff + (c ? -1 : 1), M);
+  return +(-(wholeMonthDiff + (b - anchor) / (c ? anchor - anchor2 : anchor2 - anchor)) || 0);
+};
+
+var absFloor = function absFloor(n) {
+  return n < 0 ? Math.ceil(n) || 0 : Math.floor(n);
+};
+
+var prettyUnit = function prettyUnit(u) {
+  var special = {
+    M: M,
+    y: Y,
+    w: W,
+    d: D,
+    D: DATE,
+    h: H,
+    m: MIN,
+    s: S,
+    ms: MS,
+    Q: Q
+  };
+  return special[u] || String(u || '').toLowerCase().replace(/s$/, '');
+};
+
+var isUndefined = function isUndefined(s) {
+  return s === undefined;
+};
+
+const U = {
+  s: padStart,
+  z: padZoneStr,
+  m: monthDiff,
+  a: absFloor,
+  p: prettyUnit,
+  u: isUndefined
+};
+
+var L = 'en'; // global locale
+
+var Ls = {}; // global loaded locale
+
+Ls[L] = en;
+var IS_DAYJS = '$isDayjsObject'; // eslint-disable-next-line no-use-before-define
+
+var isDayjs = function isDayjs(d) {
+  return d instanceof Dayjs || !!(d && d[IS_DAYJS]);
+};
+
+var parseLocale = function parseLocale(preset, object, isLocal) {
+  var l;
+  if (!preset) return L;
+
+  if (typeof preset === 'string') {
+    var presetLower = preset.toLowerCase();
+
+    if (Ls[presetLower]) {
+      l = presetLower;
+    }
+
+    if (object) {
+      Ls[presetLower] = object;
+      l = presetLower;
+    }
+
+    var presetSplit = preset.split('-');
+
+    if (!l && presetSplit.length > 1) {
+      return parseLocale(presetSplit[0]);
+    }
+  } else {
+    var name = preset.name;
+    Ls[name] = preset;
+    l = name;
+  }
+
+  if (!isLocal && l) L = l;
+  return l || !isLocal && L;
+};
+
+var dayjs = function dayjs(date, c) {
+  if (isDayjs(date)) {
+    return date.clone();
+  } // eslint-disable-next-line no-nested-ternary
+
+
+  var cfg = typeof c === 'object' ? c : {};
+  cfg.date = date;
+  cfg.args = arguments; // eslint-disable-line prefer-rest-params
+
+  return new Dayjs(cfg); // eslint-disable-line no-use-before-define
+};
+
+var wrapper = function wrapper(date, instance) {
+  return dayjs(date, {
+    locale: instance.$L,
+    utc: instance.$u,
+    x: instance.$x,
+    $offset: instance.$offset // todo: refactor; do not use this.$offset in you code
+
+  });
+};
+
+var Utils = U; // for plugin use
+
+Utils.l = parseLocale;
+Utils.i = isDayjs;
+Utils.w = wrapper;
+
+var parseDate = function parseDate(cfg) {
+  var date = cfg.date,
+      utc = cfg.utc;
+  if (date === null) return new Date(NaN); // null is invalid
+
+  if (Utils.u(date)) return new Date(); // today
+
+  if (date instanceof Date) return new Date(date);
+
+  if (typeof date === 'string' && !/Z$/i.test(date)) {
+    var d = date.match(REGEX_PARSE);
+
+    if (d) {
+      var m = d[2] - 1 || 0;
+      var ms = (d[7] || '0').substring(0, 3);
+
+      if (utc) {
+        return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms));
+      }
+
+      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
+    }
+  }
+
+  return new Date(date); // everything else
+};
+
+var Dayjs = /*#__PURE__*/function () {
+  function Dayjs(cfg) {
+    this.$L = parseLocale(cfg.locale, null, true);
+    this.parse(cfg); // for plugin
+
+    this.$x = this.$x || cfg.x || {};
+    this[IS_DAYJS] = true;
+  }
+
+  var _proto = Dayjs.prototype;
+
+  _proto.parse = function parse(cfg) {
+    this.$d = parseDate(cfg);
+    this.init();
+  };
+
+  _proto.init = function init() {
+    var $d = this.$d;
+    this.$y = $d.getFullYear();
+    this.$M = $d.getMonth();
+    this.$D = $d.getDate();
+    this.$W = $d.getDay();
+    this.$H = $d.getHours();
+    this.$m = $d.getMinutes();
+    this.$s = $d.getSeconds();
+    this.$ms = $d.getMilliseconds();
+  } // eslint-disable-next-line class-methods-use-this
+  ;
+
+  _proto.$utils = function $utils() {
+    return Utils;
+  };
+
+  _proto.isValid = function isValid() {
+    return !(this.$d.toString() === INVALID_DATE_STRING);
+  };
+
+  _proto.isSame = function isSame(that, units) {
+    var other = dayjs(that);
+    return this.startOf(units) <= other && other <= this.endOf(units);
+  };
+
+  _proto.isAfter = function isAfter(that, units) {
+    return dayjs(that) < this.startOf(units);
+  };
+
+  _proto.isBefore = function isBefore(that, units) {
+    return this.endOf(units) < dayjs(that);
+  };
+
+  _proto.$g = function $g(input, get, set) {
+    if (Utils.u(input)) return this[get];
+    return this.set(set, input);
+  };
+
+  _proto.unix = function unix() {
+    return Math.floor(this.valueOf() / 1000);
+  };
+
+  _proto.valueOf = function valueOf() {
+    // timezone(hour) * 60 * 60 * 1000 => ms
+    return this.$d.getTime();
+  };
+
+  _proto.startOf = function startOf(units, _startOf) {
+    var _this = this;
+
+    // startOf -> endOf
+    var isStartOf = !Utils.u(_startOf) ? _startOf : true;
+    var unit = Utils.p(units);
+
+    var instanceFactory = function instanceFactory(d, m) {
+      var ins = Utils.w(_this.$u ? Date.UTC(_this.$y, m, d) : new Date(_this.$y, m, d), _this);
+      return isStartOf ? ins : ins.endOf(D);
+    };
+
+    var instanceFactorySet = function instanceFactorySet(method, slice) {
+      var argumentStart = [0, 0, 0, 0];
+      var argumentEnd = [23, 59, 59, 999];
+      return Utils.w(_this.toDate()[method].apply( // eslint-disable-line prefer-spread
+      _this.toDate('s'), (isStartOf ? argumentStart : argumentEnd).slice(slice)), _this);
+    };
+
+    var $W = this.$W,
+        $M = this.$M,
+        $D = this.$D;
+    var utcPad = "set" + (this.$u ? 'UTC' : '');
+
+    switch (unit) {
+      case Y:
+        return isStartOf ? instanceFactory(1, 0) : instanceFactory(31, 11);
+
+      case M:
+        return isStartOf ? instanceFactory(1, $M) : instanceFactory(0, $M + 1);
+
+      case W:
+        {
+          var weekStart = this.$locale().weekStart || 0;
+          var gap = ($W < weekStart ? $W + 7 : $W) - weekStart;
+          return instanceFactory(isStartOf ? $D - gap : $D + (6 - gap), $M);
+        }
+
+      case D:
+      case DATE:
+        return instanceFactorySet(utcPad + "Hours", 0);
+
+      case H:
+        return instanceFactorySet(utcPad + "Minutes", 1);
+
+      case MIN:
+        return instanceFactorySet(utcPad + "Seconds", 2);
+
+      case S:
+        return instanceFactorySet(utcPad + "Milliseconds", 3);
+
+      default:
+        return this.clone();
+    }
+  };
+
+  _proto.endOf = function endOf(arg) {
+    return this.startOf(arg, false);
+  };
+
+  _proto.$set = function $set(units, _int) {
+    var _C$D$C$DATE$C$M$C$Y$C;
+
+    // private set
+    var unit = Utils.p(units);
+    var utcPad = "set" + (this.$u ? 'UTC' : '');
+    var name = (_C$D$C$DATE$C$M$C$Y$C = {}, _C$D$C$DATE$C$M$C$Y$C[D] = utcPad + "Date", _C$D$C$DATE$C$M$C$Y$C[DATE] = utcPad + "Date", _C$D$C$DATE$C$M$C$Y$C[M] = utcPad + "Month", _C$D$C$DATE$C$M$C$Y$C[Y] = utcPad + "FullYear", _C$D$C$DATE$C$M$C$Y$C[H] = utcPad + "Hours", _C$D$C$DATE$C$M$C$Y$C[MIN] = utcPad + "Minutes", _C$D$C$DATE$C$M$C$Y$C[S] = utcPad + "Seconds", _C$D$C$DATE$C$M$C$Y$C[MS] = utcPad + "Milliseconds", _C$D$C$DATE$C$M$C$Y$C)[unit];
+    var arg = unit === D ? this.$D + (_int - this.$W) : _int;
+
+    if (unit === M || unit === Y) {
+      // clone is for badMutable plugin
+      var date = this.clone().set(DATE, 1);
+      date.$d[name](arg);
+      date.init();
+      this.$d = date.set(DATE, Math.min(this.$D, date.daysInMonth())).$d;
+    } else if (name) this.$d[name](arg);
+
+    this.init();
+    return this;
+  };
+
+  _proto.set = function set(string, _int2) {
+    return this.clone().$set(string, _int2);
+  };
+
+  _proto.get = function get(unit) {
+    return this[Utils.p(unit)]();
+  };
+
+  _proto.add = function add(number, units) {
+    var _this2 = this,
+        _C$MIN$C$H$C$S$unit;
+
+    number = Number(number); // eslint-disable-line no-param-reassign
+
+    var unit = Utils.p(units);
+
+    var instanceFactorySet = function instanceFactorySet(n) {
+      var d = dayjs(_this2);
+      return Utils.w(d.date(d.date() + Math.round(n * number)), _this2);
+    };
+
+    if (unit === M) {
+      return this.set(M, this.$M + number);
+    }
+
+    if (unit === Y) {
+      return this.set(Y, this.$y + number);
+    }
+
+    if (unit === D) {
+      return instanceFactorySet(1);
+    }
+
+    if (unit === W) {
+      return instanceFactorySet(7);
+    }
+
+    var step = (_C$MIN$C$H$C$S$unit = {}, _C$MIN$C$H$C$S$unit[MIN] = MILLISECONDS_A_MINUTE, _C$MIN$C$H$C$S$unit[H] = MILLISECONDS_A_HOUR, _C$MIN$C$H$C$S$unit[S] = MILLISECONDS_A_SECOND, _C$MIN$C$H$C$S$unit)[unit] || 1; // ms
+
+    var nextTimeStamp = this.$d.getTime() + number * step;
+    return Utils.w(nextTimeStamp, this);
+  };
+
+  _proto.subtract = function subtract(number, string) {
+    return this.add(number * -1, string);
+  };
+
+  _proto.format = function format(formatStr) {
+    var _this3 = this;
+
+    var locale = this.$locale();
+    if (!this.isValid()) return locale.invalidDate || INVALID_DATE_STRING;
+    var str = formatStr || FORMAT_DEFAULT;
+    var zoneStr = Utils.z(this);
+    var $H = this.$H,
+        $m = this.$m,
+        $M = this.$M;
+    var weekdays = locale.weekdays,
+        months = locale.months,
+        meridiem = locale.meridiem;
+
+    var getShort = function getShort(arr, index, full, length) {
+      return arr && (arr[index] || arr(_this3, str)) || full[index].slice(0, length);
+    };
+
+    var get$H = function get$H(num) {
+      return Utils.s($H % 12 || 12, num, '0');
+    };
+
+    var meridiemFunc = meridiem || function (hour, minute, isLowercase) {
+      var m = hour < 12 ? 'AM' : 'PM';
+      return isLowercase ? m.toLowerCase() : m;
+    };
+
+    var matches = function matches(match) {
+      switch (match) {
+        case 'YY':
+          return String(_this3.$y).slice(-2);
+
+        case 'YYYY':
+          return Utils.s(_this3.$y, 4, '0');
+
+        case 'M':
+          return $M + 1;
+
+        case 'MM':
+          return Utils.s($M + 1, 2, '0');
+
+        case 'MMM':
+          return getShort(locale.monthsShort, $M, months, 3);
+
+        case 'MMMM':
+          return getShort(months, $M);
+
+        case 'D':
+          return _this3.$D;
+
+        case 'DD':
+          return Utils.s(_this3.$D, 2, '0');
+
+        case 'd':
+          return String(_this3.$W);
+
+        case 'dd':
+          return getShort(locale.weekdaysMin, _this3.$W, weekdays, 2);
+
+        case 'ddd':
+          return getShort(locale.weekdaysShort, _this3.$W, weekdays, 3);
+
+        case 'dddd':
+          return weekdays[_this3.$W];
+
+        case 'H':
+          return String($H);
+
+        case 'HH':
+          return Utils.s($H, 2, '0');
+
+        case 'h':
+          return get$H(1);
+
+        case 'hh':
+          return get$H(2);
+
+        case 'a':
+          return meridiemFunc($H, $m, true);
+
+        case 'A':
+          return meridiemFunc($H, $m, false);
+
+        case 'm':
+          return String($m);
+
+        case 'mm':
+          return Utils.s($m, 2, '0');
+
+        case 's':
+          return String(_this3.$s);
+
+        case 'ss':
+          return Utils.s(_this3.$s, 2, '0');
+
+        case 'SSS':
+          return Utils.s(_this3.$ms, 3, '0');
+
+        case 'Z':
+          return zoneStr;
+      }
+
+      return null;
+    };
+
+    return str.replace(REGEX_FORMAT, function (match, $1) {
+      return $1 || matches(match) || zoneStr.replace(':', '');
+    }); // 'ZZ'
+  };
+
+  _proto.utcOffset = function utcOffset() {
+    // Because a bug at FF24, we're rounding the timezone offset around 15 minutes
+    // https://github.com/moment/moment/pull/1871
+    return -Math.round(this.$d.getTimezoneOffset() / 15) * 15;
+  };
+
+  _proto.diff = function diff(input, units, _float) {
+    var _this4 = this;
+
+    var unit = Utils.p(units);
+    var that = dayjs(input);
+    var zoneDelta = (that.utcOffset() - this.utcOffset()) * MILLISECONDS_A_MINUTE;
+    var diff = this - that;
+
+    var getMonth = function getMonth() {
+      return Utils.m(_this4, that);
+    };
+
+    var result;
+
+    switch (unit) {
+      case Y:
+        result = getMonth() / 12;
+        break;
+
+      case M:
+        result = getMonth();
+        break;
+
+      case Q:
+        result = getMonth() / 3;
+        break;
+
+      case W:
+        result = (diff - zoneDelta) / MILLISECONDS_A_WEEK;
+        break;
+
+      case D:
+        result = (diff - zoneDelta) / MILLISECONDS_A_DAY;
+        break;
+
+      case H:
+        result = diff / MILLISECONDS_A_HOUR;
+        break;
+
+      case MIN:
+        result = diff / MILLISECONDS_A_MINUTE;
+        break;
+
+      case S:
+        result = diff / MILLISECONDS_A_SECOND;
+        break;
+
+      default:
+        result = diff; // milliseconds
+
+        break;
+    }
+
+    return _float ? result : Utils.a(result);
+  };
+
+  _proto.daysInMonth = function daysInMonth() {
+    return this.endOf(M).$D;
+  };
+
+  _proto.$locale = function $locale() {
+    // get locale object
+    return Ls[this.$L];
+  };
+
+  _proto.locale = function locale(preset, object) {
+    if (!preset) return this.$L;
+    var that = this.clone();
+    var nextLocaleName = parseLocale(preset, object, true);
+    if (nextLocaleName) that.$L = nextLocaleName;
+    return that;
+  };
+
+  _proto.clone = function clone() {
+    return Utils.w(this.$d, this);
+  };
+
+  _proto.toDate = function toDate() {
+    return new Date(this.valueOf());
+  };
+
+  _proto.toJSON = function toJSON() {
+    return this.isValid() ? this.toISOString() : null;
+  };
+
+  _proto.toISOString = function toISOString() {
+    // ie 8 return
+    // new Dayjs(this.valueOf() + this.$d.getTimezoneOffset() * 60000)
+    // .format('YYYY-MM-DDTHH:mm:ss.SSS[Z]')
+    return this.$d.toISOString();
+  };
+
+  _proto.toString = function toString() {
+    return this.$d.toUTCString();
+  };
+
+  return Dayjs;
+}();
+
+var proto = Dayjs.prototype;
+dayjs.prototype = proto;
+[['$ms', MS], ['$s', S], ['$m', MIN], ['$H', H], ['$W', D], ['$M', M], ['$y', Y], ['$D', DATE]].forEach(function (g) {
+  proto[g[1]] = function (input) {
+    return this.$g(input, g[0], g[1]);
+  };
+});
+
+dayjs.extend = function (plugin, option) {
+  if (!plugin.$i) {
+    // install plugin only once
+    plugin(option, Dayjs, dayjs);
+    plugin.$i = true;
+  }
+
+  return dayjs;
+};
+
+dayjs.locale = parseLocale;
+dayjs.isDayjs = isDayjs;
+
+dayjs.unix = function (timestamp) {
+  return dayjs(timestamp * 1e3);
+};
+
+dayjs.en = Ls[L];
+dayjs.Ls = Ls;
+dayjs.p = {};
+
+// eslint-disable-next-line import/prefer-default-export
+var t = function t(format) {
+  return format.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function (_, a, b) {
+    return a || b.slice(1);
+  });
+};
+var englishFormats = {
+  LTS: 'h:mm:ss A',
+  LT: 'h:mm A',
+  L: 'MM/DD/YYYY',
+  LL: 'MMMM D, YYYY',
+  LLL: 'MMMM D, YYYY h:mm A',
+  LLLL: 'dddd, MMMM D, YYYY h:mm A'
+};
+var u = function u(formatStr, formats) {
+  return formatStr.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function (_, a, b) {
+    var B = b && b.toUpperCase();
+    return a || formats[b] || englishFormats[b] || t(formats[B]);
+  });
+};
+
+var formattingTokens = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g;
+var match1 = /\d/; // 0 - 9
+
+var match2 = /\d\d/; // 00 - 99
+
+var match3 = /\d{3}/; // 000 - 999
+
+var match4 = /\d{4}/; // 0000 - 9999
+
+var match1to2 = /\d\d?/; // 0 - 99
+
+var matchSigned = /[+-]?\d+/; // -inf - inf
+
+var matchOffset = /[+-]\d\d:?(\d\d)?|Z/; // +00:00 -00:00 +0000 or -0000 +00 or Z
+
+var matchWord = /\d*[^-_:/,()\s\d]+/; // Word
+
+var locale = {};
+
+var parseTwoDigitYear = function parseTwoDigitYear(input) {
+  input = +input;
+  return input + (input > 68 ? 1900 : 2000);
+};
+
+function offsetFromString(string) {
+  if (!string) return 0;
+  if (string === 'Z') return 0;
+  var parts = string.match(/([+-]|\d\d)/g);
+  var minutes = +(parts[1] * 60) + (+parts[2] || 0);
+  return minutes === 0 ? 0 : parts[0] === '+' ? -minutes : minutes; // eslint-disable-line no-nested-ternary
+}
+
+var addInput = function addInput(property) {
+  return function (input) {
+    this[property] = +input;
+  };
+};
+
+var zoneExpressions = [matchOffset, function (input) {
+  var zone = this.zone || (this.zone = {});
+  zone.offset = offsetFromString(input);
+}];
+
+var getLocalePart = function getLocalePart(name) {
+  var part = locale[name];
+  return part && (part.indexOf ? part : part.s.concat(part.f));
+};
+
+var meridiemMatch = function meridiemMatch(input, isLowerCase) {
+  var isAfternoon;
+  var _locale = locale,
+      meridiem = _locale.meridiem;
+
+  if (!meridiem) {
+    isAfternoon = input === (isLowerCase ? 'pm' : 'PM');
+  } else {
+    for (var i = 1; i <= 24; i += 1) {
+      // todo: fix input === meridiem(i, 0, isLowerCase)
+      if (input.indexOf(meridiem(i, 0, isLowerCase)) > -1) {
+        isAfternoon = i > 12;
+        break;
+      }
+    }
+  }
+
+  return isAfternoon;
+};
+
+var expressions = {
+  A: [matchWord, function (input) {
+    this.afternoon = meridiemMatch(input, false);
+  }],
+  a: [matchWord, function (input) {
+    this.afternoon = meridiemMatch(input, true);
+  }],
+  S: [match1, function (input) {
+    this.milliseconds = +input * 100;
+  }],
+  SS: [match2, function (input) {
+    this.milliseconds = +input * 10;
+  }],
+  SSS: [match3, function (input) {
+    this.milliseconds = +input;
+  }],
+  s: [match1to2, addInput('seconds')],
+  ss: [match1to2, addInput('seconds')],
+  m: [match1to2, addInput('minutes')],
+  mm: [match1to2, addInput('minutes')],
+  H: [match1to2, addInput('hours')],
+  h: [match1to2, addInput('hours')],
+  HH: [match1to2, addInput('hours')],
+  hh: [match1to2, addInput('hours')],
+  D: [match1to2, addInput('day')],
+  DD: [match2, addInput('day')],
+  Do: [matchWord, function (input) {
+    var _locale2 = locale,
+        ordinal = _locale2.ordinal;
+
+    var _input$match = input.match(/\d+/);
+
+    this.day = _input$match[0];
+    if (!ordinal) return;
+
+    for (var i = 1; i <= 31; i += 1) {
+      if (ordinal(i).replace(/\[|\]/g, '') === input) {
+        this.day = i;
+      }
+    }
+  }],
+  M: [match1to2, addInput('month')],
+  MM: [match2, addInput('month')],
+  MMM: [matchWord, function (input) {
+    var months = getLocalePart('months');
+    var monthsShort = getLocalePart('monthsShort');
+    var matchIndex = (monthsShort || months.map(function (_) {
+      return _.slice(0, 3);
+    })).indexOf(input) + 1;
+
+    if (matchIndex < 1) {
+      throw new Error();
+    }
+
+    this.month = matchIndex % 12 || matchIndex;
+  }],
+  MMMM: [matchWord, function (input) {
+    var months = getLocalePart('months');
+    var matchIndex = months.indexOf(input) + 1;
+
+    if (matchIndex < 1) {
+      throw new Error();
+    }
+
+    this.month = matchIndex % 12 || matchIndex;
+  }],
+  Y: [matchSigned, addInput('year')],
+  YY: [match2, function (input) {
+    this.year = parseTwoDigitYear(input);
+  }],
+  YYYY: [match4, addInput('year')],
+  Z: zoneExpressions,
+  ZZ: zoneExpressions
+};
+
+function correctHours(time) {
+  var afternoon = time.afternoon;
+
+  if (afternoon !== undefined) {
+    var hours = time.hours;
+
+    if (afternoon) {
+      if (hours < 12) {
+        time.hours += 12;
+      }
+    } else if (hours === 12) {
+      time.hours = 0;
+    }
+
+    delete time.afternoon;
+  }
+}
+
+function makeParser(format) {
+  format = u(format, locale && locale.formats);
+  var array = format.match(formattingTokens);
+  var length = array.length;
+
+  for (var i = 0; i < length; i += 1) {
+    var token = array[i];
+    var parseTo = expressions[token];
+    var regex = parseTo && parseTo[0];
+    var parser = parseTo && parseTo[1];
+
+    if (parser) {
+      array[i] = {
+        regex: regex,
+        parser: parser
+      };
+    } else {
+      array[i] = token.replace(/^\[|\]$/g, '');
+    }
+  }
+
+  return function (input) {
+    var time = {};
+
+    for (var _i = 0, start = 0; _i < length; _i += 1) {
+      var _token = array[_i];
+
+      if (typeof _token === 'string') {
+        start += _token.length;
+      } else {
+        var _regex = _token.regex,
+            _parser = _token.parser;
+        var part = input.slice(start);
+
+        var match = _regex.exec(part);
+
+        var value = match[0];
+
+        _parser.call(time, value);
+
+        input = input.replace(value, '');
+      }
+    }
+
+    correctHours(time);
+    return time;
+  };
+}
+
+var parseFormattedInput = function parseFormattedInput(input, format, utc) {
+  try {
+    if (['x', 'X'].indexOf(format) > -1) return new Date((format === 'X' ? 1000 : 1) * input);
+    var parser = makeParser(format);
+
+    var _parser2 = parser(input),
+        year = _parser2.year,
+        month = _parser2.month,
+        day = _parser2.day,
+        hours = _parser2.hours,
+        minutes = _parser2.minutes,
+        seconds = _parser2.seconds,
+        milliseconds = _parser2.milliseconds,
+        zone = _parser2.zone;
+
+    var now = new Date();
+    var d = day || (!year && !month ? now.getDate() : 1);
+    var y = year || now.getFullYear();
+    var M = 0;
+
+    if (!(year && !month)) {
+      M = month > 0 ? month - 1 : now.getMonth();
+    }
+
+    var h = hours || 0;
+    var m = minutes || 0;
+    var s = seconds || 0;
+    var ms = milliseconds || 0;
+
+    if (zone) {
+      return new Date(Date.UTC(y, M, d, h, m, s, ms + zone.offset * 60 * 1000));
+    }
+
+    if (utc) {
+      return new Date(Date.UTC(y, M, d, h, m, s, ms));
+    }
+
+    return new Date(y, M, d, h, m, s, ms);
+  } catch (e) {
+    return new Date(''); // Invalid Date
+  }
+};
+
+const customParseFormat = (function (o, C, d) {
+  d.p.customParseFormat = true;
+
+  if (o && o.parseTwoDigitYear) {
+    parseTwoDigitYear = o.parseTwoDigitYear;
+  }
+
+  var proto = C.prototype;
+  var oldParse = proto.parse;
+
+  proto.parse = function (cfg) {
+    var date = cfg.date,
+        utc = cfg.utc,
+        args = cfg.args;
+    this.$u = utc;
+    var format = args[1];
+
+    if (typeof format === 'string') {
+      var isStrictWithoutLocale = args[2] === true;
+      var isStrictWithLocale = args[3] === true;
+      var isStrict = isStrictWithoutLocale || isStrictWithLocale;
+      var pl = args[2];
+
+      if (isStrictWithLocale) {
+        pl = args[2];
+      }
+
+      locale = this.$locale();
+
+      if (!isStrictWithoutLocale && pl) {
+        locale = d.Ls[pl];
+      }
+
+      this.$d = parseFormattedInput(date, format, utc);
+      this.init();
+      if (pl && pl !== true) this.$L = this.locale(pl).$L; // use != to treat
+      // input number 1410715640579 and format string '1410715640579' equal
+      // eslint-disable-next-line eqeqeq
+
+      if (isStrict && date != this.format(format)) {
+        this.$d = new Date('');
+      } // reset global locale to make parallel unit test
+
+
+      locale = {};
+    } else if (format instanceof Array) {
+      var len = format.length;
+
+      for (var i = 1; i <= len; i += 1) {
+        args[1] = format[i - 1];
+        var result = d.apply(this, args);
+
+        if (result.isValid()) {
+          this.$d = result.$d;
+          this.$L = result.$L;
+          this.init();
+          break;
+        }
+
+        if (i === len) this.$d = new Date('');
+      }
+    } else {
+      oldParse.call(this, cfg);
+    }
+  };
+});
+
+const localeData = (function (o, c, dayjs) {
+  // locale needed later
+  var proto = c.prototype;
+
+  var getLocalePart = function getLocalePart(part) {
+    return part && (part.indexOf ? part : part.s);
+  };
+
+  var getShort = function getShort(ins, target, full, num, localeOrder) {
+    var locale = ins.name ? ins : ins.$locale();
+    var targetLocale = getLocalePart(locale[target]);
+    var fullLocale = getLocalePart(locale[full]);
+    var result = targetLocale || fullLocale.map(function (f) {
+      return f.slice(0, num);
+    });
+    if (!localeOrder) return result;
+    var weekStart = locale.weekStart;
+    return result.map(function (_, index) {
+      return result[(index + (weekStart || 0)) % 7];
+    });
+  };
+
+  var getDayjsLocaleObject = function getDayjsLocaleObject() {
+    return dayjs.Ls[dayjs.locale()];
+  };
+
+  var getLongDateFormat = function getLongDateFormat(l, format) {
+    return l.formats[format] || t(l.formats[format.toUpperCase()]);
+  };
+
+  var localeData = function localeData() {
+    var _this = this;
+
+    return {
+      months: function months(instance) {
+        return instance ? instance.format('MMMM') : getShort(_this, 'months');
+      },
+      monthsShort: function monthsShort(instance) {
+        return instance ? instance.format('MMM') : getShort(_this, 'monthsShort', 'months', 3);
+      },
+      firstDayOfWeek: function firstDayOfWeek() {
+        return _this.$locale().weekStart || 0;
+      },
+      weekdays: function weekdays(instance) {
+        return instance ? instance.format('dddd') : getShort(_this, 'weekdays');
+      },
+      weekdaysMin: function weekdaysMin(instance) {
+        return instance ? instance.format('dd') : getShort(_this, 'weekdaysMin', 'weekdays', 2);
+      },
+      weekdaysShort: function weekdaysShort(instance) {
+        return instance ? instance.format('ddd') : getShort(_this, 'weekdaysShort', 'weekdays', 3);
+      },
+      longDateFormat: function longDateFormat(format) {
+        return getLongDateFormat(_this.$locale(), format);
+      },
+      meridiem: this.$locale().meridiem,
+      ordinal: this.$locale().ordinal
+    };
+  };
+
+  proto.localeData = function () {
+    return localeData.bind(this)();
+  };
+
+  dayjs.localeData = function () {
+    var localeObject = getDayjsLocaleObject();
+    return {
+      firstDayOfWeek: function firstDayOfWeek() {
+        return localeObject.weekStart || 0;
+      },
+      weekdays: function weekdays() {
+        return dayjs.weekdays();
+      },
+      weekdaysShort: function weekdaysShort() {
+        return dayjs.weekdaysShort();
+      },
+      weekdaysMin: function weekdaysMin() {
+        return dayjs.weekdaysMin();
+      },
+      months: function months() {
+        return dayjs.months();
+      },
+      monthsShort: function monthsShort() {
+        return dayjs.monthsShort();
+      },
+      longDateFormat: function longDateFormat(format) {
+        return getLongDateFormat(localeObject, format);
+      },
+      meridiem: localeObject.meridiem,
+      ordinal: localeObject.ordinal
+    };
+  };
+
+  dayjs.months = function () {
+    return getShort(getDayjsLocaleObject(), 'months');
+  };
+
+  dayjs.monthsShort = function () {
+    return getShort(getDayjsLocaleObject(), 'monthsShort', 'months', 3);
+  };
+
+  dayjs.weekdays = function (localeOrder) {
+    return getShort(getDayjsLocaleObject(), 'weekdays', null, null, localeOrder);
+  };
+
+  dayjs.weekdaysShort = function (localeOrder) {
+    return getShort(getDayjsLocaleObject(), 'weekdaysShort', 'weekdays', 3, localeOrder);
+  };
+
+  dayjs.weekdaysMin = function (localeOrder) {
+    return getShort(getDayjsLocaleObject(), 'weekdaysMin', 'weekdays', 2, localeOrder);
+  };
+});
+
+const localizedFormat = (function (o, c, d) {
+  var proto = c.prototype;
+  var oldFormat = proto.format;
+  d.en.formats = englishFormats;
+
+  proto.format = function (formatStr) {
+    if (formatStr === void 0) {
+      formatStr = FORMAT_DEFAULT;
+    }
+
+    var _this$$locale = this.$locale(),
+        _this$$locale$formats = _this$$locale.formats,
+        formats = _this$$locale$formats === void 0 ? {} : _this$$locale$formats;
+
+    var result = u(formatStr, formats);
+    return oldFormat.call(this, result);
+  };
+});
+
+// Plugin template from https://day.js.org/docs/en/plugin/plugin
+const preParsePostFormat = (function (option, dayjsClass) {
+  var oldParse = dayjsClass.prototype.parse;
+
+  dayjsClass.prototype.parse = function (cfg) {
+    if (typeof cfg.date === 'string') {
+      var locale = this.$locale();
+      cfg.date = locale && locale.preparse ? locale.preparse(cfg.date) : cfg.date;
+    } // original parse result
+
+
+    return oldParse.bind(this)(cfg);
+  }; // // overriding existing API
+  // // e.g. extend dayjs().format()
+
+
+  var oldFormat = dayjsClass.prototype.format;
+
+  dayjsClass.prototype.format = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    // original format result
+    var result = oldFormat.call.apply(oldFormat, [this].concat(args)); // return modified result
+
+    var locale = this.$locale();
+    return locale && locale.postformat ? locale.postformat(result) : result;
+  };
+
+  var oldFromTo = dayjsClass.prototype.fromToBase;
+
+  if (oldFromTo) {
+    dayjsClass.prototype.fromToBase = function (input, withoutSuffix, instance, isFrom) {
+      var locale = this.$locale() || instance.$locale(); // original format result
+
+      return oldFromTo.call(this, input, withoutSuffix, instance, isFrom, locale && locale.postformat);
+    };
+  }
+});
+
+const updateLocale = (function (option, Dayjs, dayjs) {
+  dayjs.updateLocale = function (locale, customConfig) {
+    var localeList = dayjs.Ls;
+    var localeConfig = localeList[locale];
+    if (!localeConfig) return;
+    var customConfigKeys = customConfig ? Object.keys(customConfig) : [];
+    customConfigKeys.forEach(function (c) {
+      localeConfig[c] = customConfig[c];
+    });
+    return localeConfig; // eslint-disable-line consistent-return
+  };
+});
+
+const maxTenthForMinuteAndSecond = 5;
+function createLocaleDateTimeFormatter(locale, numberingSystem, includeSeconds = true, fractionalSecondDigits) {
+    const options = {
+        hour: "2-digit",
+        minute: "2-digit",
+        timeZone: "UTC",
+        numberingSystem: getSupportedNumberingSystem(numberingSystem),
+    };
+    if (includeSeconds) {
+        options.second = "2-digit";
+        if (fractionalSecondDigits) {
+            options.fractionalSecondDigits = fractionalSecondDigits;
+        }
+    }
+    return getDateTimeFormat(locale, options);
+}
+function formatTimePart(number, minLength) {
+    if (number === null || number === undefined) {
+        return;
+    }
+    const numberAsString = number.toString();
+    const numberDecimalPlaces = decimalPlaces(number);
+    if (number < 1 && numberDecimalPlaces > 0 && numberDecimalPlaces < 4) {
+        const fractionalDigits = numberAsString.replace("0.", "");
+        if (!minLength || fractionalDigits.length === minLength) {
+            return fractionalDigits;
+        }
+        if (fractionalDigits.length < minLength) {
+            return fractionalDigits.padEnd(minLength, "0");
+        }
+        return fractionalDigits;
+    }
+    if (number >= 0 && number < 10) {
+        return numberAsString.padStart(2, "0");
+    }
+    if (number >= 10) {
+        return numberAsString;
+    }
+}
+function formatTimeString(value) {
+    if (!isValidTime(value)) {
+        return null;
+    }
+    const { hour, minute, second, fractionalSecond } = parseTimeString(value);
+    let formattedValue = `${formatTimePart(parseInt(hour))}:${formatTimePart(parseInt(minute))}`;
+    if (second) {
+        formattedValue += `:${formatTimePart(parseInt(second))}`;
+        if (fractionalSecond) {
+            formattedValue += `.${fractionalSecond}`;
+        }
+    }
+    return formattedValue;
+}
+function fractionalSecondPartToMilliseconds(fractionalSecondPart) {
+    return parseInt((parseFloat(`0.${fractionalSecondPart}`) / 0.001).toFixed(3));
+}
+function getLocaleHourCycle(locale, numberingSystem) {
+    const formatter = createLocaleDateTimeFormatter(locale, numberingSystem);
+    const parts = formatter.formatToParts(new Date(Date.UTC(0, 0, 0, 0, 0, 0)));
+    return getLocalizedTimePart("meridiem", parts) ? "12" : "24";
+}
+function getLocalizedDecimalSeparator(locale, numberingSystem) {
+    numberStringFormatter.numberFormatOptions = {
+        locale,
+        numberingSystem,
+    };
+    return numberStringFormatter.localize("1.1").split("")[1];
+}
+function getLocalizedTimePartSuffix(part, locale, numberingSystem = "latn") {
+    const formatter = createLocaleDateTimeFormatter(locale, numberingSystem);
+    const parts = formatter.formatToParts(new Date(Date.UTC(0, 0, 0, 0, 0, 0)));
+    return getLocalizedTimePart(`${part}Suffix`, parts);
+}
+function getLocalizedTimePart(part, parts) {
+    if (!part || !parts) {
+        return null;
+    }
+    if (part === "hourSuffix") {
+        const hourIndex = parts.indexOf(parts.find(({ type }) => type === "hour"));
+        const minuteIndex = parts.indexOf(parts.find(({ type }) => type === "minute"));
+        const hourSuffix = parts[hourIndex + 1];
+        return hourSuffix && hourSuffix.type === "literal" && minuteIndex - hourIndex === 2
+            ? hourSuffix.value?.trim() || null
+            : null;
+    }
+    if (part === "minuteSuffix") {
+        const minuteIndex = parts.indexOf(parts.find(({ type }) => type === "minute"));
+        const secondIndex = parts.indexOf(parts.find(({ type }) => type === "second"));
+        const minuteSuffix = parts[minuteIndex + 1];
+        return minuteSuffix && minuteSuffix.type === "literal" && secondIndex - minuteIndex === 2
+            ? minuteSuffix.value?.trim() || null
+            : null;
+    }
+    if (part === "secondSuffix") {
+        const secondIndex = parts.indexOf(parts.find(({ type }) => type === "second"));
+        const secondSuffix = parts[secondIndex + 1];
+        return secondSuffix && secondSuffix.type === "literal" ? secondSuffix.value?.trim() || null : null;
+    }
+    return parts.find(({ type }) => (part == "meridiem" ? type === "dayPeriod" : type === part))?.value || null;
+}
+function getMeridiem(hour) {
+    if (!isValidNumber(hour)) {
+        return null;
+    }
+    const hourAsNumber = parseInt(hour);
+    return hourAsNumber >= 0 && hourAsNumber <= 11 ? "AM" : "PM";
+}
+function isValidTime(value) {
+    if (!value || value.startsWith(":") || value.endsWith(":")) {
+        return false;
+    }
+    const splitValue = value.split(":");
+    const validLength = splitValue.length > 1 && splitValue.length < 4;
+    if (!validLength) {
+        return false;
+    }
+    const [hour, minute, second] = splitValue;
+    const hourAsNumber = parseInt(splitValue[0]);
+    const minuteAsNumber = parseInt(splitValue[1]);
+    const secondAsNumber = parseInt(splitValue[2]);
+    const hourValid = isValidNumber(hour) && hourAsNumber >= 0 && hourAsNumber < 24;
+    const minuteValid = isValidNumber(minute) && minuteAsNumber >= 0 && minuteAsNumber < 60;
+    const secondValid = isValidNumber(second) && secondAsNumber >= 0 && secondAsNumber < 60;
+    if ((hourValid && minuteValid && !second) || (hourValid && minuteValid && secondValid)) {
+        return true;
+    }
+}
+function isValidTimePart(value, part) {
+    if (part === "meridiem") {
+        return value === "AM" || value === "PM";
+    }
+    if (!isValidNumber(value)) {
+        return false;
+    }
+    const valueAsNumber = Number(value);
+    return part === "hour" ? valueAsNumber >= 0 && valueAsNumber < 24 : valueAsNumber >= 0 && valueAsNumber < 60;
+}
+function localizeTimePart({ value, part, locale, numberingSystem }) {
+    if (part === "fractionalSecond") {
+        const localizedDecimalSeparator = getLocalizedDecimalSeparator(locale, numberingSystem);
+        let localizedFractionalSecond = null;
+        if (value) {
+            numberStringFormatter.numberFormatOptions = {
+                locale,
+                numberingSystem,
+            };
+            const localizedZero = numberStringFormatter.localize("0");
+            if (parseInt(value) === 0) {
+                localizedFractionalSecond = "".padStart(value.length, localizedZero);
+            }
+            else {
+                localizedFractionalSecond = numberStringFormatter
+                    .localize(`0.${value}`)
+                    .replace(`${localizedZero}${localizedDecimalSeparator}`, "");
+                if (localizedFractionalSecond.length < value.length) {
+                    localizedFractionalSecond = localizedFractionalSecond.padEnd(value.length, localizedZero);
+                }
+            }
+        }
+        return localizedFractionalSecond;
+    }
+    if (!isValidTimePart(value, part)) {
+        return;
+    }
+    const valueAsNumber = parseInt(value);
+    const date = new Date(Date.UTC(0, 0, 0, part === "hour" ? valueAsNumber : part === "meridiem" ? (value === "AM" ? 0 : 12) : 0, part === "minute" ? valueAsNumber : 0, part === "second" ? valueAsNumber : 0));
+    if (!date) {
+        return;
+    }
+    const formatter = createLocaleDateTimeFormatter(locale, numberingSystem);
+    const parts = formatter.formatToParts(date);
+    return getLocalizedTimePart(part, parts);
+}
+function localizeTimeString({ value, locale, numberingSystem, includeSeconds = true, fractionalSecondDigits, }) {
+    if (!isValidTime(value)) {
+        return null;
+    }
+    const { hour, minute, second = "0", fractionalSecond } = parseTimeString(value);
+    const dateFromTimeString = new Date(Date.UTC(0, 0, 0, parseInt(hour), parseInt(minute), parseInt(second), fractionalSecond && fractionalSecondPartToMilliseconds(fractionalSecond)));
+    const formatter = createLocaleDateTimeFormatter(locale, numberingSystem, includeSeconds, fractionalSecondDigits);
+    return formatter.format(dateFromTimeString) || null;
+}
+function localizeTimeStringToParts({ value, locale, numberingSystem = "latn", }) {
+    if (!isValidTime(value)) {
+        return null;
+    }
+    const { hour, minute, second = "0", fractionalSecond } = parseTimeString(value);
+    const dateFromTimeString = new Date(Date.UTC(0, 0, 0, parseInt(hour), parseInt(minute), parseInt(second)));
+    if (dateFromTimeString) {
+        const formatter = createLocaleDateTimeFormatter(locale, numberingSystem);
+        const parts = formatter.formatToParts(dateFromTimeString);
+        return {
+            localizedHour: getLocalizedTimePart("hour", parts),
+            localizedHourSuffix: getLocalizedTimePart("hourSuffix", parts),
+            localizedMinute: getLocalizedTimePart("minute", parts),
+            localizedMinuteSuffix: getLocalizedTimePart("minuteSuffix", parts),
+            localizedSecond: getLocalizedTimePart("second", parts),
+            localizedDecimalSeparator: getLocalizedDecimalSeparator(locale, numberingSystem),
+            localizedFractionalSecond: localizeTimePart({
+                value: fractionalSecond,
+                part: "fractionalSecond",
+                locale,
+                numberingSystem,
+            }),
+            localizedSecondSuffix: getLocalizedTimePart("secondSuffix", parts),
+            localizedMeridiem: getLocalizedTimePart("meridiem", parts),
+        };
+    }
+    return null;
+}
+function getTimeParts({ value, locale, numberingSystem }) {
+    if (!isValidTime(value)) {
+        return null;
+    }
+    const { hour, minute, second = "0" } = parseTimeString(value);
+    const dateFromTimeString = new Date(Date.UTC(0, 0, 0, parseInt(hour), parseInt(minute), parseInt(second)));
+    if (dateFromTimeString) {
+        const formatter = createLocaleDateTimeFormatter(locale, numberingSystem);
+        const parts = formatter.formatToParts(dateFromTimeString);
+        return parts;
+    }
+    return null;
+}
+function parseTimeString(value) {
+    if (isValidTime(value)) {
+        const [hour, minute, secondDecimal] = value.split(":");
+        let second = secondDecimal;
+        let fractionalSecond = null;
+        if (secondDecimal?.includes(".")) {
+            [second, fractionalSecond] = secondDecimal.split(".");
+        }
+        return {
+            fractionalSecond,
+            hour,
+            minute,
+            second,
+        };
+    }
+    return {
+        fractionalSecond: null,
+        hour: null,
+        minute: null,
+        second: null,
+    };
+}
+function toISOTimeString(value, includeSeconds = true) {
+    if (!isValidTime(value)) {
+        return "";
+    }
+    const { hour, minute, second, fractionalSecond } = parseTimeString(value);
+    let isoTimeString = `${formatTimePart(parseInt(hour))}:${formatTimePart(parseInt(minute))}`;
+    if (includeSeconds) {
+        isoTimeString += `:${formatTimePart(parseInt((includeSeconds && second) || "0"))}`;
+        if (fractionalSecond) {
+            isoTimeString += `.${fractionalSecond}`;
+        }
+    }
+    return isoTimeString;
+}
+
+const CSS$1 = {
+    toggleIcon: "toggle-icon",
+};
+
+const inputTimePickerCss = ":host([disabled]){cursor:default;-webkit-user-select:none;user-select:none;opacity:var(--calcite-opacity-disabled)}:host([disabled]) *,:host([disabled]) ::slotted(*){pointer-events:none}:host{display:inline-block;-webkit-user-select:none;user-select:none}:host([disabled]) ::slotted([calcite-hydrated][disabled]),:host([disabled]) [calcite-hydrated][disabled]{opacity:1}.interaction-container{display:contents}::slotted(input[slot=hidden-form-input]){margin:0 !important;opacity:0 !important;outline:none !important;padding:0 !important;position:absolute !important;inset:0 !important;transform:none !important;-webkit-appearance:none !important;z-index:-1 !important}:host([scale=s]){--calcite-toggle-spacing:0.5rem;--calcite-internal-input-text-input-padding-inline-end:calc(var(--calcite-toggle-spacing) + 1rem)}:host([scale=m]){--calcite-toggle-spacing:0.75rem;--calcite-internal-input-text-input-padding-inline-end:calc(var(--calcite-toggle-spacing) + 1.5rem)}:host([scale=l]){--calcite-toggle-spacing:1rem;--calcite-internal-input-text-input-padding-inline-end:calc(var(--calcite-toggle-spacing) + 2rem)}.input-wrapper{position:relative}.toggle-icon{position:absolute;display:flex;cursor:pointer;align-items:center;inset-inline-end:0;inset-block:0;padding-inline:var(--calcite-toggle-spacing);--calcite-ui-icon-color:var(--calcite-color-text-3)}.input-wrapper:hover .toggle-icon,calcite-input-text:focus+.toggle-icon{--calcite-ui-icon-color:var(--calcite-color-text-1)}.validation-container{display:flex;flex-direction:column;align-items:flex-start;align-self:stretch}:host([scale=m]) .validation-container,:host([scale=l]) .validation-container{padding-block-start:0.5rem}:host([scale=s]) .validation-container{padding-block-start:0.25rem}:host([hidden]){display:none}[hidden]{display:none}";
+const CalciteInputTimePickerStyle0 = inputTimePickerCss;
+
+// some bundlers (e.g., Webpack) need dynamic import paths to be static
+const supportedDayjsLocaleToLocaleConfigImport = new Map([
+    ["ar", () => import('./ar-eb8890a2.js')],
+    ["bg", () => import('./bg-13c95e29.js')],
+    ["bs", () => import('./bs-75cb1bfb.js')],
+    ["ca", () => import('./ca-128421ee.js')],
+    ["cs", () => import('./cs-2f6c9547.js')],
+    ["da", () => import('./da-5faeb180.js')],
+    ["de", () => import('./de-588019ef.js')],
+    ["de-at", () => import('./de-at-fed09c43.js')],
+    ["de-ch", () => import('./de-ch-8705386b.js')],
+    ["el", () => import('./el-a64a4d60.js')],
+    ["en", () => Promise.resolve().then(function () { return en$1; })],
+    ["en-au", () => import('./en-au-e0b06d67.js')],
+    ["en-ca", () => import('./en-ca-3962cb62.js')],
+    ["en-gb", () => import('./en-gb-9ced14f5.js')],
+    ["es", () => import('./es-04700092.js')],
+    ["es-mx", () => import('./es-mx-26ffb23c.js')],
+    ["et", () => import('./et-b19d3747.js')],
+    ["fi", () => import('./fi-3f4715da.js')],
+    ["fr", () => import('./fr-e9b074bf.js')],
+    ["fr-ch", () => import('./fr-ch-6b9fa39a.js')],
+    ["he", () => import('./he-bf4df957.js')],
+    ["hi", () => import('./hi-234cc865.js')],
+    ["hr", () => import('./hr-106f0bce.js')],
+    ["hu", () => import('./hu-47562123.js')],
+    ["id", () => import('./id-76c4b37d.js')],
+    ["it", () => import('./it-58ddf940.js')],
+    ["it-ch", () => import('./it-ch-c465d1f9.js')],
+    ["ja", () => import('./ja-e590b060.js')],
+    ["ko", () => import('./ko-ca2373c2.js')],
+    ["lt", () => import('./lt-baf966fa.js')],
+    ["lv", () => import('./lv-5b4f2333.js')],
+    ["mk", () => import('./mk-88c4b4a8.js')],
+    ["nl", () => import('./nl-404ac698.js')],
+    ["nb", () => import('./nb-dea1151c.js')],
+    ["pl", () => import('./pl-78c6d26e.js')],
+    ["pt", () => import('./pt-dc2dfdf6.js')],
+    ["pt-br", () => import('./pt-br-e4c84e47.js')],
+    ["ro", () => import('./ro-deecb816.js')],
+    ["ru", () => import('./ru-0af2b53b.js')],
+    ["sk", () => import('./sk-2e239854.js')],
+    ["sl", () => import('./sl-7530e14d.js')],
+    ["sr", () => import('./sr-513c77f6.js')],
+    ["sv", () => import('./sv-ff0dc066.js')],
+    ["th", () => import('./th-70a93839.js')],
+    ["tr", () => import('./tr-f8181fad.js')],
+    ["uk", () => import('./uk-d32d9d4b.js')],
+    ["vi", () => import('./vi-94ae687c.js')],
+    ["zh-cn", () => import('./zh-cn-307d2358.js')],
+    ["zh-hk", () => import('./zh-hk-1d23e09c.js')],
+    ["zh-tw", () => import('./zh-tw-91b016e8.js')],
+]);
+dayjs.extend(customParseFormat);
+dayjs.extend(localeData);
+dayjs.extend(localizedFormat);
+dayjs.extend(preParsePostFormat);
+dayjs.extend(updateLocale);
+const InputTimePicker = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.calciteInputTimePickerBeforeClose = createEvent(this, "calciteInputTimePickerBeforeClose", 6);
+        this.calciteInputTimePickerBeforeOpen = createEvent(this, "calciteInputTimePickerBeforeOpen", 6);
+        this.calciteInputTimePickerChange = createEvent(this, "calciteInputTimePickerChange", 7);
+        this.calciteInputTimePickerClose = createEvent(this, "calciteInputTimePickerClose", 6);
+        this.calciteInputTimePickerOpen = createEvent(this, "calciteInputTimePickerOpen", 6);
+        this.focusOnOpen = false;
+        this.dialogId = `time-picker-dialog--${guid()}`;
+        /** whether the value of the input was changed as a result of user typing or not */
+        this.userChangedValue = false;
+        this.referenceElementId = `input-time-picker-${guid()}`;
+        this.openTransitionProp = "opacity";
+        //--------------------------------------------------------------------------
+        //
+        //  Event Listeners
+        //
+        //--------------------------------------------------------------------------
+        this.hostBlurHandler = () => {
+            const inputValue = this.calciteInputEl.value;
+            const delocalizedInputValue = this.delocalizeTimeString(inputValue);
+            if (!delocalizedInputValue) {
+                this.setValue("");
+                return;
+            }
+            if (delocalizedInputValue !== this.value) {
+                this.setValue(delocalizedInputValue);
+            }
+            const localizedTimeString = localizeTimeString({
+                value: this.value,
+                locale: this.effectiveLocale,
+                numberingSystem: this.numberingSystem,
+                includeSeconds: this.shouldIncludeSeconds(),
+                fractionalSecondDigits: decimalPlaces(this.step),
+            });
+            if (localizedTimeString !== inputValue) {
+                this.setInputValue(localizedTimeString);
+            }
+            this.deactivate();
+        };
+        this.calciteInternalInputFocusHandler = (event) => {
+            if (!this.readOnly) {
+                event.stopPropagation();
+            }
+        };
+        this.calciteInternalInputInputHandler = (event) => {
+            const { effectiveLocale: locale, numberingSystem } = this;
+            if (numberingSystem && numberingSystem !== "latn") {
+                const target = event.target;
+                numberStringFormatter.numberFormatOptions = {
+                    locale,
+                    numberingSystem,
+                    useGrouping: false,
+                };
+                const valueInNumberingSystem = numberStringFormatter
+                    .delocalize(target.value)
+                    .split("")
+                    .map((char) => numberKeys.includes(char)
+                    ? numberStringFormatter.numberFormatter.format(Number(char))
+                    : char)
+                    .join("");
+                this.setInputValue(valueInNumberingSystem);
+            }
+        };
+        this.timePickerChangeHandler = (event) => {
+            event.stopPropagation();
+            const target = event.target;
+            const value = target.value;
+            const includeSeconds = this.shouldIncludeSeconds();
+            this.setValue(toISOTimeString(value, includeSeconds));
+            this.setInputValue(localizeTimeString({
+                value,
+                locale: this.effectiveLocale,
+                numberingSystem: this.numberingSystem,
+                includeSeconds,
+                fractionalSecondDigits: decimalPlaces(this.step),
+            }));
+        };
+        this.popoverCloseHandler = () => {
+            deactivateFocusTrap(this, {
+                onDeactivate: () => {
+                    this.calciteInputEl.setFocus();
+                    this.focusOnOpen = false;
+                },
+            });
+            this.open = false;
+        };
+        this.popoverOpenHandler = () => {
+            activateFocusTrap(this, {
+                onActivate: () => {
+                    if (this.focusOnOpen) {
+                        this.calciteTimePickerEl.setFocus();
+                        this.focusOnOpen = false;
+                    }
+                },
+            });
+        };
+        this.keyDownHandler = (event) => {
+            const { defaultPrevented, key } = event;
+            if (defaultPrevented) {
+                return;
+            }
+            if (key === "Enter") {
+                if (submitForm(this)) {
+                    event.preventDefault();
+                    this.calciteInputEl.setFocus();
+                }
+                if (event.composedPath().includes(this.calciteTimePickerEl)) {
+                    return;
+                }
+                const newValue = this.delocalizeTimeString(this.calciteInputEl.value);
+                if (isValidTime(newValue)) {
+                    this.setValue(newValue);
+                    const localizedTimeString = localizeTimeString({
+                        value: this.value,
+                        locale: this.effectiveLocale,
+                        numberingSystem: this.numberingSystem,
+                        includeSeconds: this.shouldIncludeSeconds(),
+                        fractionalSecondDigits: decimalPlaces(this.step),
+                    });
+                    if (newValue && this.calciteInputEl.value !== localizedTimeString) {
+                        this.setInputValue(localizedTimeString);
+                    }
+                }
+            }
+            else if (key === "ArrowDown") {
+                this.open = true;
+                this.focusOnOpen = true;
+                event.preventDefault();
+            }
+            else if (key === "Escape" && this.open) {
+                this.open = false;
+                event.preventDefault();
+                this.calciteInputEl.setFocus();
+            }
+        };
+        this.setCalcitePopoverEl = (el) => {
+            this.popoverEl = el;
+        };
+        this.setInputAndTransitionEl = (el) => {
+            this.calciteInputEl = el;
+            this.transitionEl = el;
+        };
+        this.setCalciteTimePickerEl = (el) => {
+            this.calciteTimePickerEl = el;
+            connectFocusTrap(this, {
+                focusTrapEl: el,
+                focusTrapOptions: {
+                    initialFocus: false,
+                    setReturnFocus: false,
+                },
+            });
+        };
+        this.setInputValue = (newInputValue) => {
+            if (!this.calciteInputEl) {
+                return;
+            }
+            this.calciteInputEl.value = newInputValue;
+        };
+        /**
+         * Sets the value and emits a change event.
+         * This is used to update the value as a result of user interaction.
+         *
+         * @param value
+         */
+        this.setValue = (value) => {
+            const oldValue = this.value;
+            const newValue = formatTimeString(value) || "";
+            if (newValue === oldValue) {
+                return;
+            }
+            this.userChangedValue = true;
+            this.value = newValue || "";
+            const changeEvent = this.calciteInputTimePickerChange.emit();
+            if (changeEvent.defaultPrevented) {
+                this.userChangedValue = false;
+                this.value = oldValue;
+                this.setInputValue(localizeTimeString({
+                    value: oldValue,
+                    locale: this.effectiveLocale,
+                    numberingSystem: this.numberingSystem,
+                    includeSeconds: this.shouldIncludeSeconds(),
+                    fractionalSecondDigits: decimalPlaces(this.step),
+                }));
+            }
+        };
+        /**
+         * Sets the value directly without emitting a change event.
+         * This is used to update the value on initial load and when props change that are not the result of user interaction.
+         *
+         * @param value
+         */
+        this.setValueDirectly = (value) => {
+            const includeSeconds = this.shouldIncludeSeconds();
+            this.value = toISOTimeString(value, includeSeconds);
+            this.setInputValue(this.value
+                ? localizeTimeString({
+                    value: this.value,
+                    includeSeconds,
+                    locale: this.effectiveLocale,
+                    numberingSystem: this.numberingSystem,
+                    fractionalSecondDigits: decimalPlaces(this.step),
+                })
+                : "");
+        };
+        this.onInputWrapperClick = () => {
+            this.open = !this.open;
+        };
+        this.deactivate = () => {
+            this.open = false;
+        };
+        this.open = false;
+        this.disabled = false;
+        this.focusTrapDisabled = false;
+        this.form = undefined;
+        this.readOnly = false;
+        this.messageOverrides = undefined;
+        this.messages = undefined;
+        this.validationMessage = undefined;
+        this.validationIcon = undefined;
+        this.validity = {
+            valid: false,
+            badInput: false,
+            customError: false,
+            patternMismatch: false,
+            rangeOverflow: false,
+            rangeUnderflow: false,
+            stepMismatch: false,
+            tooLong: false,
+            tooShort: false,
+            typeMismatch: false,
+            valueMissing: false,
+        };
+        this.name = undefined;
+        this.numberingSystem = undefined;
+        this.required = false;
+        this.scale = "m";
+        this.status = "idle";
+        this.overlayPositioning = "absolute";
+        this.placement = "auto";
+        this.step = 60;
+        this.value = null;
+        this.defaultMessages = undefined;
+        this.effectiveLocale = "";
+    }
+    openHandler() {
+        onToggleOpenCloseComponent(this);
+        if (this.disabled || this.readOnly) {
+            this.open = false;
+            return;
+        }
+        this.reposition(true);
+    }
+    handleFocusTrapDisabled(focusTrapDisabled) {
+        if (!this.open) {
+            return;
+        }
+        focusTrapDisabled ? deactivateFocusTrap(this) : activateFocusTrap(this);
+    }
+    handleDisabledAndReadOnlyChange(value) {
+        if (!value) {
+            this.open = false;
+        }
+    }
+    onMessagesChange() {
+        /* wired up by t9n util */
+    }
+    numberingSystemWatcher(numberingSystem) {
+        this.setInputValue(localizeTimeString({
+            value: this.value,
+            locale: this.effectiveLocale,
+            numberingSystem,
+            includeSeconds: this.shouldIncludeSeconds(),
+            fractionalSecondDigits: decimalPlaces(this.step),
+        }));
+    }
+    stepWatcher(newStep, oldStep) {
+        if ((oldStep >= 60 && newStep > 0 && newStep < 60) ||
+            (newStep >= 60 && oldStep > 0 && oldStep < 60)) {
+            this.setValueDirectly(this.value);
+        }
+    }
+    valueWatcher(newValue) {
+        if (!this.userChangedValue) {
+            this.setValueDirectly(newValue);
+        }
+        this.userChangedValue = false;
+    }
+    async effectiveLocaleWatcher(locale) {
+        await this.loadDateTimeLocaleData();
+        this.setInputValue(localizeTimeString({
+            value: this.value,
+            locale,
+            numberingSystem: this.numberingSystem,
+            includeSeconds: this.shouldIncludeSeconds(),
+            fractionalSecondDigits: decimalPlaces(this.step),
+        }));
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Public Methods
+    //
+    // --------------------------------------------------------------------------
+    /** Sets focus on the component. */
+    async setFocus() {
+        await componentFocusable(this);
+        this.el.focus();
+    }
+    /**
+     * Updates the position of the component.
+     *
+     * @param delayed
+     */
+    async reposition(delayed = false) {
+        this.popoverEl?.reposition(delayed);
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    // --------------------------------------------------------------------------
+    onBeforeOpen() {
+        this.calciteInputTimePickerBeforeOpen.emit();
+    }
+    onOpen() {
+        this.calciteInputTimePickerOpen.emit();
+    }
+    onBeforeClose() {
+        this.calciteInputTimePickerBeforeClose.emit();
+    }
+    onClose() {
+        this.calciteInputTimePickerClose.emit();
+    }
+    delocalizeTimeString(value) {
+        // we need to set the corresponding locale before parsing, otherwise it defaults to English (possible dayjs bug)
+        dayjs.locale(this.effectiveLocale.toLowerCase());
+        const nonFractionalSecondParts = this.delocalizeTimeStringToParts(value);
+        let delocalizedTimeString;
+        if (this.shouldIncludeFractionalSeconds()) {
+            const stepPrecision = decimalPlaces(this.step);
+            const centisecondParts = this.delocalizeTimeStringToParts(value, "S");
+            if (stepPrecision === 1) {
+                delocalizedTimeString =
+                    centisecondParts.millisecond !== 0
+                        ? this.getTimeStringFromParts(centisecondParts)
+                        : this.getTimeStringFromParts(nonFractionalSecondParts);
+            }
+            else {
+                const decisecondParts = this.delocalizeTimeStringToParts(value, "SS");
+                if (stepPrecision === 2) {
+                    if (decisecondParts.millisecond !== 0) {
+                        delocalizedTimeString = this.getTimeStringFromParts(decisecondParts);
+                    }
+                    else if (centisecondParts.millisecond !== 0) {
+                        delocalizedTimeString = this.getTimeStringFromParts(centisecondParts);
+                    }
+                    else {
+                        delocalizedTimeString = this.getTimeStringFromParts(nonFractionalSecondParts);
+                    }
+                }
+                else if (stepPrecision >= 3) {
+                    const millisecondParts = this.delocalizeTimeStringToParts(value, "SSS");
+                    if (millisecondParts.millisecond !== 0) {
+                        delocalizedTimeString = this.getTimeStringFromParts(millisecondParts);
+                    }
+                    else if (decisecondParts.millisecond !== 0) {
+                        delocalizedTimeString = this.getTimeStringFromParts(decisecondParts);
+                    }
+                    else if (centisecondParts.millisecond !== 0) {
+                        delocalizedTimeString = this.getTimeStringFromParts(centisecondParts);
+                    }
+                    else {
+                        delocalizedTimeString = this.getTimeStringFromParts(nonFractionalSecondParts);
+                    }
+                }
+            }
+        }
+        else {
+            delocalizedTimeString = this.getTimeStringFromParts(nonFractionalSecondParts);
+        }
+        return delocalizedTimeString;
+    }
+    delocalizeTimeStringToParts(localizedTimeString, fractionalSecondFormatToken) {
+        const ltsFormatString = this.localeConfig?.formats?.LTS;
+        const fractionalSecondTokenMatch = ltsFormatString.match(/ss\.*(S+)/g);
+        if (fractionalSecondFormatToken && this.shouldIncludeFractionalSeconds()) {
+            const secondFormatToken = `ss.${fractionalSecondFormatToken}`;
+            this.localeConfig.formats.LTS = fractionalSecondTokenMatch
+                ? ltsFormatString.replace(fractionalSecondTokenMatch[0], secondFormatToken)
+                : ltsFormatString.replace("ss", secondFormatToken);
+        }
+        else if (fractionalSecondTokenMatch) {
+            this.localeConfig.formats.LTS = ltsFormatString.replace(fractionalSecondTokenMatch[0], "ss");
+        }
+        dayjs.updateLocale(this.getSupportedDayjsLocale(getSupportedLocale(this.effectiveLocale)), this.localeConfig);
+        const dayjsParseResult = dayjs(localizedTimeString, ["LTS", "LT"]);
+        if (dayjsParseResult.isValid()) {
+            return {
+                hour: dayjsParseResult.get("hour"),
+                minute: dayjsParseResult.get("minute"),
+                second: dayjsParseResult.get("second"),
+                millisecond: dayjsParseResult.get("millisecond"),
+            };
+        }
+        return {
+            hour: null,
+            minute: null,
+            second: null,
+            millisecond: null,
+        };
+    }
+    getTimeStringFromParts(parts) {
+        let timeString = "";
+        if (!parts) {
+            return timeString;
+        }
+        if (parts.hour !== null && parts.minute !== null) {
+            timeString = `${formatTimePart(parts.hour)}:${formatTimePart(parts.minute)}`;
+            if (this.shouldIncludeSeconds() && parts.second !== null) {
+                timeString += `:${formatTimePart(parts.second)}`;
+                if (this.shouldIncludeFractionalSeconds() && parts.millisecond !== null) {
+                    const second = (parts.millisecond * 0.001).toFixed(decimalPlaces(this.step));
+                    timeString += `.${second.toString().replace("0.", "")}`;
+                }
+            }
+        }
+        return timeString;
+    }
+    getSupportedDayjsLocale(locale) {
+        const dayjsLocale = locale.toLowerCase();
+        if (dayjsLocale === "no") {
+            return "nb";
+        }
+        if (dayjsLocale === "pt-pt") {
+            return "pt";
+        }
+        return dayjsLocale;
+    }
+    async loadDateTimeLocaleData() {
+        let supportedLocale = getSupportedLocale(this.effectiveLocale).toLowerCase();
+        supportedLocale = this.getSupportedDayjsLocale(supportedLocale);
+        const { default: localeConfig } = await supportedDayjsLocaleToLocaleConfigImport.get(supportedLocale)();
+        this.localeConfig = localeConfig;
+        dayjs.locale(this.localeConfig, null, true);
+        dayjs.updateLocale(supportedLocale, this.getExtendedLocaleConfig(supportedLocale));
+    }
+    getExtendedLocaleConfig(locale) {
+        if (locale === "ar") {
+            return {
+                meridiem: (hour) => (hour > 12 ? "م" : "ص"),
+                formats: {
+                    LT: "HH:mm A",
+                    LTS: "HH:mm:ss A",
+                    L: "DD/MM/YYYY",
+                    LL: "D MMMM YYYY",
+                    LLL: "D MMMM YYYY HH:mm A",
+                    LLLL: "dddd D MMMM YYYY HH:mm A",
+                },
+            };
+        }
+        if (locale === "en-au") {
+            return {
+                meridiem: (hour) => (hour > 12 ? "pm" : "am"),
+            };
+        }
+        if (locale === "en-ca") {
+            return {
+                meridiem: (hour) => (hour > 12 ? "p.m." : "a.m."),
+            };
+        }
+        if (locale === "el") {
+            return {
+                meridiem: (hour) => (hour > 12 ? "μ.μ." : "π.μ."),
+            };
+        }
+        if (locale === "hi") {
+            return {
+                formats: {
+                    LT: "h:mm A",
+                    LTS: "h:mm:ss A",
+                    L: "DD/MM/YYYY",
+                    LL: "D MMMM YYYY",
+                    LLL: "D MMMM YYYY, h:mm A",
+                    LLLL: "dddd, D MMMM YYYY, h:mm A",
+                },
+                meridiem: (hour) => (hour > 12 ? "pm" : "am"),
+            };
+        }
+        if (locale === "ko") {
+            return {
+                meridiem: (hour) => (hour > 12 ? "오후" : "오전"),
+            };
+        }
+        if (locale === "zh-tw") {
+            return {
+                formats: {
+                    LT: "AHH:mm",
+                    LTS: "AHH:mm:ss",
+                },
+            };
+        }
+        if (locale === "zh-hk") {
+            return {
+                formats: {
+                    LT: "AHH:mm",
+                    LTS: "AHH:mm:ss",
+                },
+                meridiem: (hour) => (hour > 12 ? "下午" : "上午"),
+            };
+        }
+    }
+    onLabelClick() {
+        this.setFocus();
+    }
+    shouldIncludeSeconds() {
+        return this.step < 60;
+    }
+    shouldIncludeFractionalSeconds() {
+        return decimalPlaces(this.step) > 0;
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    //--------------------------------------------------------------------------
+    connectedCallback() {
+        connectInteractive(this);
+        connectLocalized(this);
+        if (isValidTime(this.value)) {
+            this.setValueDirectly(this.value);
+        }
+        else {
+            this.value = undefined;
+        }
+        connectLabel(this);
+        connectForm(this);
+        connectMessages(this);
+    }
+    async componentWillLoad() {
+        setUpLoadableComponent(this);
+        await Promise.all([setUpMessages(this), this.loadDateTimeLocaleData()]);
+        if (this.open) {
+            onToggleOpenCloseComponent(this);
+        }
+    }
+    componentDidLoad() {
+        setComponentLoaded(this);
+        if (isValidTime(this.value)) {
+            this.setInputValue(localizeTimeString({
+                value: this.value,
+                locale: this.effectiveLocale,
+                numberingSystem: this.numberingSystem,
+                includeSeconds: this.shouldIncludeSeconds(),
+                fractionalSecondDigits: decimalPlaces(this.step),
+            }));
+        }
+    }
+    disconnectedCallback() {
+        disconnectInteractive(this);
+        disconnectLabel(this);
+        disconnectForm(this);
+        disconnectLocalized(this);
+        deactivateFocusTrap(this);
+        disconnectMessages(this);
+    }
+    componentDidRender() {
+        updateHostInteraction(this);
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Render Methods
+    //
+    // --------------------------------------------------------------------------
+    render() {
+        const { disabled, messages, readOnly, dialogId } = this;
+        return (h(Host, { key: '561e33708dcc90afdba91d4072b7979ff11f79c7', onBlur: this.hostBlurHandler, onKeyDown: this.keyDownHandler }, h(InteractiveContainer, { key: '19c3360f4640bce039a46d8cb06a8927855bf13c', disabled: this.disabled }, h("div", { key: 'e48f09d0b5179e75e55cc9664f880bd350543d6a', class: "input-wrapper", onClick: this.onInputWrapperClick }, h("calcite-input-text", { key: '717afb03fbcf590ebf927fe4bd0005a00e5fe2ec', "aria-autocomplete": "none", "aria-haspopup": "dialog", disabled: disabled, icon: "clock", id: this.referenceElementId, label: getLabelText(this), lang: this.effectiveLocale, onCalciteInputTextInput: this.calciteInternalInputInputHandler, onCalciteInternalInputTextFocus: this.calciteInternalInputFocusHandler, readOnly: readOnly, role: "combobox", scale: this.scale, status: this.status,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setInputAndTransitionEl }), !this.readOnly && this.renderToggleIcon(this.open)), h("calcite-popover", { key: 'd62bfe8b3ddc24e012d84b61a05061a09e6322dd', focusTrapDisabled: true, id: dialogId, label: messages.chooseTime, lang: this.effectiveLocale, onCalcitePopoverClose: this.popoverCloseHandler, onCalcitePopoverOpen: this.popoverOpenHandler, open: this.open, overlayPositioning: this.overlayPositioning, placement: this.placement, referenceElement: this.referenceElementId, triggerDisabled: true,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setCalcitePopoverEl }, h("calcite-time-picker", { key: '6bfcee7272942b5476486a86933376b81aff7b23', lang: this.effectiveLocale, messageOverrides: this.messageOverrides, numberingSystem: this.numberingSystem, onCalciteInternalTimePickerChange: this.timePickerChangeHandler, scale: this.scale, step: this.step, tabIndex: this.open ? undefined : -1, value: this.value,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setCalciteTimePickerEl })), h(HiddenFormInputSlot, { key: '0ca8c8c04ef40e120530a4666761473b8d1b987f', component: this }), this.validationMessage && this.status === "invalid" ? (h(Validation, { icon: this.validationIcon, message: this.validationMessage, scale: this.scale, status: this.status })) : null)));
+    }
+    renderToggleIcon(open) {
+        return (h("span", { class: CSS$1.toggleIcon }, h("calcite-icon", { icon: open ? "chevron-up" : "chevron-down", scale: getIconScale(this.scale) })));
+    }
+    static get delegatesFocus() { return true; }
+    static get assetsDirs() { return ["assets"]; }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "open": ["openHandler"],
+        "focusTrapDisabled": ["handleFocusTrapDisabled"],
+        "disabled": ["handleDisabledAndReadOnlyChange"],
+        "readOnly": ["handleDisabledAndReadOnlyChange"],
+        "messageOverrides": ["onMessagesChange"],
+        "numberingSystem": ["numberingSystemWatcher"],
+        "step": ["stepWatcher"],
+        "value": ["valueWatcher"],
+        "effectiveLocale": ["effectiveLocaleWatcher"]
+    }; }
+};
+InputTimePicker.style = CalciteInputTimePickerStyle0;
+
+const CSS = {
+    button: "button",
+    buttonBottomLeft: "button--bottom-left",
+    buttonBottomRight: "button--bottom-right",
+    buttonFractionalSecondDown: "button--fractionalSecond-down",
+    buttonFractionalSecondUp: "button--fractionalSecond-up",
+    buttonHourDown: "button--hour-down",
+    buttonHourUp: "button--hour-up",
+    buttonMeridiemDown: "button--meridiem-down",
+    buttonMeridiemUp: "button--meridiem-up",
+    buttonMinuteDown: "button--minute-down",
+    buttonMinuteUp: "button--minute-up",
+    buttonSecondDown: "button--second-down",
+    buttonSecondUp: "button--second-up",
+    buttonTopLeft: "button--top-left",
+    buttonTopRight: "button--top-right",
+    column: "column",
+    delimiter: "delimiter",
+    fractionalSecond: "fractionalSecond",
+    hour: "hour",
+    input: "input",
+    inputFocus: "inputFocus",
+    meridiem: "meridiem",
+    minute: "minute",
+    second: "second",
+    showMeridiem: "show-meridiem",
+    showSecond: "show-second",
+    "scale-s": "scale-s",
+    "scale-m": "scale-m",
+    "scale-l": "scale-l",
+    timePicker: "time-picker",
+    meridiemStart: "meridiem--start",
+};
+
+const timePickerCss = ":host{display:inline-block}.time-picker{display:flex;-webkit-user-select:none;user-select:none;align-items:center;background-color:var(--calcite-color-foreground-1);font-weight:var(--calcite-font-weight-medium);color:var(--calcite-color-text-1);--tw-shadow:0 6px 20px -4px rgba(0, 0, 0, 0.1), 0 4px 12px -2px rgba(0, 0, 0, 0.08);--tw-shadow-colored:0 6px 20px -4px var(--tw-shadow-color), 0 4px 12px -2px var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);border-radius:var(--calcite-border-radius)}.time-picker .column{display:flex;flex-direction:column}.time-picker .meridiem--start{order:-1}.time-picker .button{display:inline-flex;cursor:pointer;align-items:center;justify-content:center;background-color:var(--calcite-color-foreground-1)}.time-picker .button:hover,.time-picker .button:focus{background-color:var(--calcite-color-foreground-2);outline:2px solid transparent;outline-offset:2px;z-index:var(--calcite-z-index-header);outline-offset:0}.time-picker .button:active{background-color:var(--calcite-color-foreground-3)}.time-picker .button.top-left{border-start-start-radius:var(--calcite-border-radius)}.time-picker .button.bottom-left{border-end-start-radius:var(--calcite-border-radius)}.time-picker .button.top-right{border-start-end-radius:var(--calcite-border-radius)}.time-picker .button.bottom-right{border-end-end-radius:var(--calcite-border-radius)}.time-picker .button calcite-icon{color:var(--calcite-color-text-3)}.time-picker .input{display:inline-flex;cursor:pointer;align-items:center;justify-content:center;background-color:var(--calcite-color-foreground-1);font-weight:var(--calcite-font-weight-medium)}.time-picker .input:hover{box-shadow:inset 0 0 0 2px var(--calcite-color-foreground-2);z-index:var(--calcite-z-index-header)}.time-picker .input:focus,.time-picker .input:hover:focus{outline:2px solid transparent;outline-offset:2px;outline-offset:0}.time-picker .input.inputFocus,.time-picker .input:hover.inputFocus{box-shadow:inset 0 0 0 2px var(--calcite-color-brand);z-index:var(--calcite-z-index-header)}.time-picker.scale-s{font-size:var(--calcite-font-size--1)}.time-picker.scale-s .button,.time-picker.scale-s .input{padding-inline:0.75rem;padding-block:0.25rem}.time-picker.scale-s:not(.show-meridiem) .delimiter:last-child{padding-inline-end:0.75rem}.time-picker.scale-m{font-size:var(--calcite-font-size-0)}.time-picker.scale-m .button,.time-picker.scale-m .input{padding-inline:1rem;padding-block:0.5rem}.time-picker.scale-m:not(.show-meridiem) .delimiter:last-child{padding-inline-end:1rem}.time-picker.scale-l{font-size:var(--calcite-font-size-1)}.time-picker.scale-l .button,.time-picker.scale-l .input{padding-inline:1.25rem;padding-block:0.75rem}.time-picker.scale-l:not(.show-meridiem) .delimiter:last-child{padding-inline-end:1.25rem}:host([hidden]){display:none}[hidden]{display:none}";
+const CalciteTimePickerStyle0 = timePickerCss;
+
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+const TimePicker = class {
+    constructor(hostRef) {
+        registerInstance(this, hostRef);
+        this.calciteInternalTimePickerBlur = createEvent(this, "calciteInternalTimePickerBlur", 6);
+        this.calciteInternalTimePickerChange = createEvent(this, "calciteInternalTimePickerChange", 6);
+        this.calciteInternalTimePickerFocus = createEvent(this, "calciteInternalTimePickerFocus", 6);
+        this.pointerActivated = false;
+        this.decrementHour = () => {
+            const newHour = !this.hour ? 0 : this.hour === "00" ? 23 : parseInt(this.hour) - 1;
+            this.setValuePart("hour", newHour);
+        };
+        this.decrementMeridiem = () => {
+            const newMeridiem = this.meridiem === "PM" ? "AM" : "PM";
+            this.setValuePart("meridiem", newMeridiem);
+        };
+        this.decrementMinuteOrSecond = (key) => {
+            let newValue;
+            if (isValidNumber(this[key])) {
+                const valueAsNumber = parseInt(this[key]);
+                newValue = valueAsNumber === 0 ? 59 : valueAsNumber - 1;
+            }
+            else {
+                newValue = 59;
+            }
+            this.setValuePart(key, newValue);
+        };
+        this.decrementMinute = () => {
+            this.decrementMinuteOrSecond("minute");
+        };
+        this.decrementSecond = () => {
+            this.decrementMinuteOrSecond("second");
+        };
+        this.focusHandler = (event) => {
+            if (this.pointerActivated) {
+                return;
+            }
+            this.activeEl = event.currentTarget;
+        };
+        this.fractionalSecondKeyDownHandler = (event) => {
+            const { key } = event;
+            if (numberKeys.includes(key)) {
+                const stepPrecision = decimalPlaces(this.step);
+                const fractionalSecondAsInteger = parseInt(this.fractionalSecond);
+                const fractionalSecondAsIntegerLength = fractionalSecondAsInteger.toString().length;
+                let newFractionalSecondAsIntegerString;
+                if (fractionalSecondAsIntegerLength >= stepPrecision) {
+                    newFractionalSecondAsIntegerString = key.padStart(stepPrecision, "0");
+                }
+                else if (fractionalSecondAsIntegerLength < stepPrecision) {
+                    newFractionalSecondAsIntegerString = `${fractionalSecondAsInteger}${key}`.padStart(stepPrecision, "0");
+                }
+                this.setValuePart("fractionalSecond", parseFloat(`0.${newFractionalSecondAsIntegerString}`));
+            }
+            else {
+                switch (key) {
+                    case "Backspace":
+                    case "Delete":
+                        this.setValuePart("fractionalSecond", null);
+                        break;
+                    case "ArrowDown":
+                        event.preventDefault();
+                        this.nudgeFractionalSecond("down");
+                        break;
+                    case "ArrowUp":
+                        event.preventDefault();
+                        this.nudgeFractionalSecond("up");
+                        break;
+                    case " ":
+                        event.preventDefault();
+                        break;
+                }
+            }
+        };
+        this.fractionalSecondDownClickHandler = () => {
+            this.activeEl = this.fractionalSecondEl;
+            this.fractionalSecondEl.focus();
+            this.nudgeFractionalSecond("down");
+        };
+        this.fractionalSecondUpClickHandler = () => {
+            this.activeEl = this.fractionalSecondEl;
+            this.fractionalSecondEl.focus();
+            this.nudgeFractionalSecond("up");
+        };
+        this.hourDownClickHandler = () => {
+            this.activeEl = this.hourEl;
+            this.hourEl.focus();
+            this.decrementHour();
+        };
+        this.hourKeyDownHandler = (event) => {
+            const { key } = event;
+            if (numberKeys.includes(key)) {
+                const keyAsNumber = parseInt(key);
+                let newHour;
+                if (isValidNumber(this.hour)) {
+                    switch (this.hourCycle) {
+                        case "12":
+                            newHour =
+                                this.hour === "01" && keyAsNumber >= 0 && keyAsNumber <= 2
+                                    ? `1${keyAsNumber}`
+                                    : keyAsNumber;
+                            break;
+                        case "24":
+                            if (this.hour === "01") {
+                                newHour = `1${keyAsNumber}`;
+                            }
+                            else if (this.hour === "02" && keyAsNumber >= 0 && keyAsNumber <= 3) {
+                                newHour = `2${keyAsNumber}`;
+                            }
+                            else {
+                                newHour = keyAsNumber;
+                            }
+                            break;
+                    }
+                }
+                else {
+                    newHour = keyAsNumber;
+                }
+                this.setValuePart("hour", newHour);
+            }
+            else {
+                switch (key) {
+                    case "Backspace":
+                    case "Delete":
+                        this.setValuePart("hour", null);
+                        break;
+                    case "ArrowDown":
+                        event.preventDefault();
+                        this.decrementHour();
+                        break;
+                    case "ArrowUp":
+                        event.preventDefault();
+                        this.incrementHour();
+                        break;
+                    case " ":
+                        event.preventDefault();
+                        break;
+                }
+            }
+        };
+        this.hourUpClickHandler = () => {
+            this.activeEl = this.hourEl;
+            this.hourEl.focus();
+            this.incrementHour();
+        };
+        this.incrementMeridiem = () => {
+            const newMeridiem = this.meridiem === "AM" ? "PM" : "AM";
+            this.setValuePart("meridiem", newMeridiem);
+        };
+        this.incrementHour = () => {
+            const newHour = isValidNumber(this.hour)
+                ? this.hour === "23"
+                    ? 0
+                    : parseInt(this.hour) + 1
+                : 1;
+            this.setValuePart("hour", newHour);
+        };
+        this.incrementMinuteOrSecond = (key) => {
+            const newValue = isValidNumber(this[key])
+                ? this[key] === "59"
+                    ? 0
+                    : parseInt(this[key]) + 1
+                : 0;
+            this.setValuePart(key, newValue);
+        };
+        this.incrementMinute = () => {
+            this.incrementMinuteOrSecond("minute");
+        };
+        this.incrementSecond = () => {
+            this.incrementMinuteOrSecond("second");
+        };
+        this.inputClickHandler = (event) => {
+            this.activeEl = event.target;
+        };
+        this.meridiemUpClickHandler = () => {
+            this.activeEl = this.meridiemEl;
+            this.meridiemEl.focus();
+            this.incrementMeridiem();
+        };
+        this.meridiemKeyDownHandler = (event) => {
+            switch (event.key) {
+                case "a":
+                    this.setValuePart("meridiem", "AM");
+                    break;
+                case "p":
+                    this.setValuePart("meridiem", "PM");
+                    break;
+                case "Backspace":
+                case "Delete":
+                    this.setValuePart("meridiem", null);
+                    break;
+                case "ArrowUp":
+                    event.preventDefault();
+                    this.incrementMeridiem();
+                    break;
+                case "ArrowDown":
+                    event.preventDefault();
+                    this.decrementMeridiem();
+                    break;
+                case " ":
+                    event.preventDefault();
+                    break;
+            }
+        };
+        this.meridiemDownClickHandler = () => {
+            this.activeEl = this.meridiemEl;
+            this.meridiemEl.focus();
+            this.decrementMeridiem();
+        };
+        this.minuteDownClickHandler = () => {
+            this.activeEl = this.minuteEl;
+            this.minuteEl.focus();
+            this.decrementMinute();
+        };
+        this.minuteUpClickHandler = () => {
+            this.activeEl = this.minuteEl;
+            this.minuteEl.focus();
+            this.incrementMinute();
+        };
+        this.minuteKeyDownHandler = (event) => {
+            const { key } = event;
+            if (numberKeys.includes(key)) {
+                const keyAsNumber = parseInt(key);
+                let newMinute;
+                if (isValidNumber(this.minute) && this.minute.startsWith("0")) {
+                    const minuteAsNumber = parseInt(this.minute);
+                    newMinute =
+                        minuteAsNumber > maxTenthForMinuteAndSecond
+                            ? keyAsNumber
+                            : `${minuteAsNumber}${keyAsNumber}`;
+                }
+                else {
+                    newMinute = keyAsNumber;
+                }
+                this.setValuePart("minute", newMinute);
+            }
+            else {
+                switch (key) {
+                    case "Backspace":
+                    case "Delete":
+                        this.setValuePart("minute", null);
+                        break;
+                    case "ArrowDown":
+                        event.preventDefault();
+                        this.decrementMinute();
+                        break;
+                    case "ArrowUp":
+                        event.preventDefault();
+                        this.incrementMinute();
+                        break;
+                    case " ":
+                        event.preventDefault();
+                        break;
+                }
+            }
+        };
+        this.nudgeFractionalSecond = (direction) => {
+            const stepDecimal = getDecimals(this.step);
+            const stepPrecision = decimalPlaces(this.step);
+            const fractionalSecondAsInteger = parseInt(this.fractionalSecond);
+            const fractionalSecondAsFloat = parseFloat(`0.${this.fractionalSecond}`);
+            let nudgedValue;
+            let nudgedValueRounded;
+            let nudgedValueRoundedDecimals;
+            let newFractionalSecond;
+            if (direction === "up") {
+                nudgedValue = isNaN(fractionalSecondAsInteger) ? 0 : fractionalSecondAsFloat + stepDecimal;
+                nudgedValueRounded = parseFloat(nudgedValue.toFixed(stepPrecision));
+                nudgedValueRoundedDecimals = getDecimals(nudgedValueRounded);
+                newFractionalSecond =
+                    nudgedValueRounded < 1 && decimalPlaces(nudgedValueRoundedDecimals) > 0
+                        ? formatTimePart(nudgedValueRoundedDecimals, stepPrecision)
+                        : "".padStart(stepPrecision, "0");
+            }
+            if (direction === "down") {
+                nudgedValue =
+                    isNaN(fractionalSecondAsInteger) || fractionalSecondAsInteger === 0
+                        ? 1 - stepDecimal
+                        : fractionalSecondAsFloat - stepDecimal;
+                nudgedValueRounded = parseFloat(nudgedValue.toFixed(stepPrecision));
+                nudgedValueRoundedDecimals = getDecimals(nudgedValueRounded);
+                newFractionalSecond =
+                    nudgedValueRounded < 1 &&
+                        decimalPlaces(nudgedValueRoundedDecimals) > 0 &&
+                        Math.sign(nudgedValueRoundedDecimals) === 1
+                        ? formatTimePart(nudgedValueRoundedDecimals, stepPrecision)
+                        : "".padStart(stepPrecision, "0");
+            }
+            this.setValuePart("fractionalSecond", newFractionalSecond);
+        };
+        this.sanitizeValue = (value) => {
+            const { hour, minute, second, fractionalSecond } = parseTimeString(value);
+            if (fractionalSecond) {
+                const sanitizedFractionalSecond = this.sanitizeFractionalSecond(fractionalSecond);
+                return `${hour}:${minute}:${second}.${sanitizedFractionalSecond}`;
+            }
+            return isValidTime(value) && value;
+        };
+        this.sanitizeFractionalSecond = (fractionalSecond) => fractionalSecond && decimalPlaces(this.step) !== fractionalSecond.length
+            ? parseFloat(`0.${fractionalSecond}`).toFixed(decimalPlaces(this.step)).replace("0.", "")
+            : fractionalSecond;
+        this.secondKeyDownHandler = (event) => {
+            const { key } = event;
+            if (numberKeys.includes(key)) {
+                const keyAsNumber = parseInt(key);
+                let newSecond;
+                if (isValidNumber(this.second) && this.second.startsWith("0")) {
+                    const secondAsNumber = parseInt(this.second);
+                    newSecond =
+                        secondAsNumber > maxTenthForMinuteAndSecond
+                            ? keyAsNumber
+                            : `${secondAsNumber}${keyAsNumber}`;
+                }
+                else {
+                    newSecond = keyAsNumber;
+                }
+                this.setValuePart("second", newSecond);
+            }
+            else {
+                switch (key) {
+                    case "Backspace":
+                    case "Delete":
+                        this.setValuePart("second", null);
+                        break;
+                    case "ArrowDown":
+                        event.preventDefault();
+                        this.decrementSecond();
+                        break;
+                    case "ArrowUp":
+                        event.preventDefault();
+                        this.incrementSecond();
+                        break;
+                    case " ":
+                        event.preventDefault();
+                        break;
+                }
+            }
+        };
+        this.secondDownClickHandler = () => {
+            this.activeEl = this.secondEl;
+            this.secondEl.focus();
+            this.decrementSecond();
+        };
+        this.secondUpClickHandler = () => {
+            this.activeEl = this.secondEl;
+            this.secondEl.focus();
+            this.incrementSecond();
+        };
+        this.setHourEl = (el) => (this.hourEl = el);
+        this.setMeridiemEl = (el) => (this.meridiemEl = el);
+        this.setMinuteEl = (el) => (this.minuteEl = el);
+        this.setSecondEl = (el) => (this.secondEl = el);
+        this.setFractionalSecondEl = (el) => (this.fractionalSecondEl = el);
+        this.setValue = (value) => {
+            if (isValidTime(value)) {
+                const { hour, minute, second, fractionalSecond } = parseTimeString(value);
+                const { effectiveLocale: locale, numberingSystem } = this;
+                const { localizedHour, localizedHourSuffix, localizedMinute, localizedMinuteSuffix, localizedSecond, localizedDecimalSeparator, localizedFractionalSecond, localizedSecondSuffix, localizedMeridiem, } = localizeTimeStringToParts({ value, locale, numberingSystem });
+                this.hour = hour;
+                this.minute = minute;
+                this.second = second;
+                this.fractionalSecond = this.sanitizeFractionalSecond(fractionalSecond);
+                this.localizedHour = localizedHour;
+                this.localizedHourSuffix = localizedHourSuffix;
+                this.localizedMinute = localizedMinute;
+                this.localizedMinuteSuffix = localizedMinuteSuffix;
+                this.localizedSecond = localizedSecond;
+                this.localizedDecimalSeparator = localizedDecimalSeparator;
+                this.localizedFractionalSecond = localizedFractionalSecond;
+                this.localizedSecondSuffix = localizedSecondSuffix;
+                if (localizedMeridiem) {
+                    this.localizedMeridiem = localizedMeridiem;
+                    this.meridiem = getMeridiem(this.hour);
+                    const formatParts = getTimeParts({ value, locale, numberingSystem });
+                    this.meridiemOrder = this.getMeridiemOrder(formatParts);
+                }
+            }
+            else {
+                this.hour = null;
+                this.fractionalSecond = null;
+                this.localizedHour = null;
+                this.localizedHourSuffix = getLocalizedTimePartSuffix("hour", this.effectiveLocale, this.numberingSystem);
+                this.localizedMeridiem = null;
+                this.localizedMinute = null;
+                this.localizedMinuteSuffix = getLocalizedTimePartSuffix("minute", this.effectiveLocale, this.numberingSystem);
+                this.localizedSecond = null;
+                this.localizedDecimalSeparator = getLocalizedDecimalSeparator(this.effectiveLocale, this.numberingSystem);
+                this.localizedFractionalSecond = null;
+                this.localizedSecondSuffix = getLocalizedTimePartSuffix("second", this.effectiveLocale, this.numberingSystem);
+                this.meridiem = null;
+                this.minute = null;
+                this.second = null;
+                this.value = null;
+            }
+        };
+        this.setValuePart = (key, value) => {
+            const { effectiveLocale: locale, numberingSystem } = this;
+            if (key === "meridiem") {
+                this.meridiem = value;
+                if (isValidNumber(this.hour)) {
+                    const hourAsNumber = parseInt(this.hour);
+                    switch (value) {
+                        case "AM":
+                            if (hourAsNumber >= 12) {
+                                this.hour = formatTimePart(hourAsNumber - 12);
+                            }
+                            break;
+                        case "PM":
+                            if (hourAsNumber < 12) {
+                                this.hour = formatTimePart(hourAsNumber + 12);
+                            }
+                            break;
+                    }
+                    this.localizedHour = localizeTimePart({
+                        value: this.hour,
+                        part: "hour",
+                        locale,
+                        numberingSystem,
+                    });
+                }
+            }
+            else if (key === "fractionalSecond") {
+                const stepPrecision = decimalPlaces(this.step);
+                if (typeof value === "number") {
+                    this.fractionalSecond =
+                        value === 0 ? "".padStart(stepPrecision, "0") : formatTimePart(value, stepPrecision);
+                }
+                else {
+                    this.fractionalSecond = value;
+                }
+                this.localizedFractionalSecond = localizeTimePart({
+                    value: this.fractionalSecond,
+                    part: "fractionalSecond",
+                    locale,
+                    numberingSystem,
+                });
+            }
+            else {
+                this[key] = typeof value === "number" ? formatTimePart(value) : value;
+                this[`localized${capitalize(key)}`] = localizeTimePart({
+                    value: this[key],
+                    part: key,
+                    locale,
+                    numberingSystem,
+                });
+            }
+            let emit = false;
+            let newValue;
+            if (this.hour && this.minute) {
+                newValue = `${this.hour}:${this.minute}`;
+                if (this.showSecond) {
+                    newValue = `${newValue}:${this.second ?? "00"}`;
+                    if (this.showFractionalSecond && this.fractionalSecond) {
+                        newValue = `${newValue}.${this.fractionalSecond}`;
+                    }
+                }
+            }
+            else {
+                newValue = null;
+            }
+            if (this.value !== newValue) {
+                emit = true;
+            }
+            this.value = newValue;
+            this.localizedMeridiem = this.value
+                ? localizeTimeStringToParts({ value: this.value, locale, numberingSystem })
+                    ?.localizedMeridiem || null
+                : localizeTimePart({ value: this.meridiem, part: "meridiem", locale, numberingSystem });
+            if (emit) {
+                this.calciteInternalTimePickerChange.emit();
+            }
+        };
+        this.scale = "m";
+        this.step = 60;
+        this.numberingSystem = undefined;
+        this.value = null;
+        this.messages = undefined;
+        this.messageOverrides = undefined;
+        this.activeEl = undefined;
+        this.effectiveLocale = "";
+        this.fractionalSecond = undefined;
+        this.hour = undefined;
+        this.hourCycle = undefined;
+        this.localizedDecimalSeparator = ".";
+        this.localizedHour = undefined;
+        this.localizedHourSuffix = undefined;
+        this.localizedMeridiem = undefined;
+        this.localizedFractionalSecond = undefined;
+        this.localizedMinute = undefined;
+        this.localizedMinuteSuffix = undefined;
+        this.localizedSecond = undefined;
+        this.localizedSecondSuffix = undefined;
+        this.meridiem = undefined;
+        this.minute = undefined;
+        this.second = undefined;
+        this.showFractionalSecond = undefined;
+        this.showSecond = undefined;
+        this.defaultMessages = undefined;
+    }
+    stepChange() {
+        this.toggleSecond();
+    }
+    valueWatcher(newValue) {
+        this.setValue(newValue);
+    }
+    onMessagesChange() {
+        /* wired up by t9n util */
+    }
+    effectiveLocaleWatcher() {
+        this.updateLocale();
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Event Listeners
+    //
+    //--------------------------------------------------------------------------
+    blurHandler() {
+        this.activeEl = undefined;
+        this.pointerActivated = false;
+        this.calciteInternalTimePickerBlur.emit();
+    }
+    hostFocusHandler() {
+        this.calciteInternalTimePickerFocus.emit();
+    }
+    keyDownHandler(event) {
+        this.pointerActivated = false;
+        const { defaultPrevented, key } = event;
+        if (defaultPrevented) {
+            return;
+        }
+        switch (this.activeEl) {
+            case this.hourEl:
+                if (key === "ArrowRight") {
+                    this.focusPart("minute");
+                    event.preventDefault();
+                }
+                break;
+            case this.minuteEl:
+                switch (key) {
+                    case "ArrowLeft":
+                        this.focusPart("hour");
+                        event.preventDefault();
+                        break;
+                    case "ArrowRight":
+                        if (this.step !== 60) {
+                            this.focusPart("second");
+                            event.preventDefault();
+                        }
+                        else if (this.hourCycle === "12") {
+                            this.focusPart("meridiem");
+                            event.preventDefault();
+                        }
+                        break;
+                }
+                break;
+            case this.secondEl:
+                switch (key) {
+                    case "ArrowLeft":
+                        this.focusPart("minute");
+                        event.preventDefault();
+                        break;
+                    case "ArrowRight":
+                        if (this.showFractionalSecond) {
+                            this.focusPart("fractionalSecond");
+                        }
+                        else if (this.hourCycle === "12") {
+                            this.focusPart("meridiem");
+                            event.preventDefault();
+                        }
+                        break;
+                }
+                break;
+            case this.fractionalSecondEl:
+                switch (key) {
+                    case "ArrowLeft":
+                        this.focusPart("second");
+                        event.preventDefault();
+                        break;
+                    case "ArrowRight":
+                        if (this.hourCycle === "12") {
+                            this.focusPart("meridiem");
+                            event.preventDefault();
+                        }
+                        break;
+                }
+                break;
+            case this.meridiemEl:
+                switch (key) {
+                    case "ArrowLeft":
+                        if (this.showFractionalSecond) {
+                            this.focusPart("fractionalSecond");
+                        }
+                        else if (this.step !== 60) {
+                            this.focusPart("second");
+                            event.preventDefault();
+                        }
+                        else {
+                            this.focusPart("minute");
+                            event.preventDefault();
+                        }
+                        break;
+                }
+                break;
+        }
+    }
+    pointerDownHandler() {
+        this.pointerActivated = true;
+    }
+    //--------------------------------------------------------------------------
+    //
+    //  Public Methods
+    //
+    //--------------------------------------------------------------------------
+    /**
+     * Sets focus on the component's first focusable element.
+     */
+    async setFocus() {
+        await componentFocusable(this);
+        this.el?.focus();
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Private Methods
+    //
+    // --------------------------------------------------------------------------
+    async focusPart(target) {
+        await componentFocusable(this);
+        this[`${target || "hour"}El`]?.focus();
+    }
+    toggleSecond() {
+        this.showSecond = this.step < 60;
+        this.showFractionalSecond = decimalPlaces(this.step) > 0;
+    }
+    getMeridiemOrder(formatParts) {
+        const locale = this.effectiveLocale;
+        const isRTLKind = locale === "ar" || locale === "he";
+        if (formatParts && !isRTLKind) {
+            const index = formatParts.findIndex((parts) => {
+                return parts.value === this.localizedMeridiem;
+            });
+            return index;
+        }
+        return 0;
+    }
+    updateLocale() {
+        updateMessages(this, this.effectiveLocale);
+        this.hourCycle = getLocaleHourCycle(this.effectiveLocale, this.numberingSystem);
+        this.localizedDecimalSeparator = getLocalizedDecimalSeparator(this.effectiveLocale, this.numberingSystem);
+        this.setValue(this.sanitizeValue(this.value));
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Lifecycle
+    //
+    // --------------------------------------------------------------------------
+    connectedCallback() {
+        connectLocalized(this);
+        this.updateLocale();
+        connectMessages(this);
+        this.toggleSecond();
+        this.meridiemOrder = this.getMeridiemOrder(getTimeParts({
+            value: "0:00:00",
+            locale: this.effectiveLocale,
+            numberingSystem: this.numberingSystem,
+        }));
+    }
+    async componentWillLoad() {
+        setUpLoadableComponent(this);
+        await setUpMessages(this);
+    }
+    componentDidLoad() {
+        setComponentLoaded(this);
+    }
+    disconnectedCallback() {
+        disconnectLocalized(this);
+        disconnectMessages(this);
+    }
+    // --------------------------------------------------------------------------
+    //
+    //  Render Methods
+    //
+    // --------------------------------------------------------------------------
+    render() {
+        const hourIsNumber = isValidNumber(this.hour);
+        const iconScale = getIconScale(this.scale);
+        const minuteIsNumber = isValidNumber(this.minute);
+        const secondIsNumber = isValidNumber(this.second);
+        const fractionalSecondIsNumber = isValidNumber(this.fractionalSecond);
+        const showMeridiem = this.hourCycle === "12";
+        return (h("div", { key: 'a14cbeb1861fce5acdb6c06210c62d1a60e2c7e7', class: {
+                [CSS.timePicker]: true,
+                [CSS.showMeridiem]: showMeridiem,
+                [CSS.showSecond]: this.showSecond,
+                [CSS[`scale-${this.scale}`]]: true,
+            }, dir: "ltr" }, h("div", { key: 'a53db9fc5411776df398bdf4df8a2521cc16c938', class: CSS.column, role: "group" }, h("span", { key: '117e2b1eca1cd8ee8b5f79a9cfc0b003e165967d', "aria-label": this.messages.hourUp, class: {
+                [CSS.button]: true,
+                [CSS.buttonHourUp]: true,
+                [CSS.buttonTopLeft]: true,
+            }, onClick: this.hourUpClickHandler, role: "button" }, h("calcite-icon", { key: 'd1dfd48891fb26a56873ec597ec9822b2ae9cf5e', icon: "chevron-up", scale: iconScale })), h("span", { key: '2f299ba278f86107a2ef4a34fbe8fb5d9ec05f51', "aria-label": this.messages.hour, "aria-valuemax": "23", "aria-valuemin": "1", "aria-valuenow": (hourIsNumber && parseInt(this.hour)) || "0", "aria-valuetext": this.hour, class: {
+                [CSS.input]: true,
+                [CSS.hour]: true,
+                [CSS.inputFocus]: this.activeEl && this.activeEl === this.hourEl,
+            }, onClick: this.inputClickHandler, onFocus: this.focusHandler, onKeyDown: this.hourKeyDownHandler, role: "spinbutton", tabIndex: 0,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setHourEl }, this.localizedHour || "--"), h("span", { key: '72bf35a4c3152282cdac87a9bb636dbed52652b4', "aria-label": this.messages.hourDown, class: {
+                [CSS.button]: true,
+                [CSS.buttonHourDown]: true,
+                [CSS.buttonBottomLeft]: true,
+            }, onClick: this.hourDownClickHandler, role: "button" }, h("calcite-icon", { key: '70f55cec6f85950079520f710f4bb1a76589bd90', icon: "chevron-down", scale: iconScale }))), h("span", { key: '93641650ddbbe9a0c8753034e4b4418a4dd6f33b', class: CSS.delimiter }, this.localizedHourSuffix), h("div", { key: '197cebdb724341cd763ed0a58f7c10090621fac0', class: CSS.column, role: "group" }, h("span", { key: '10a3705875f07b57c4f494af7ef2d81581985242', "aria-label": this.messages.minuteUp, class: {
+                [CSS.button]: true,
+                [CSS.buttonMinuteUp]: true,
+            }, onClick: this.minuteUpClickHandler, role: "button" }, h("calcite-icon", { key: '601b4929b942735034e37b634aac614a6640c209', icon: "chevron-up", scale: iconScale })), h("span", { key: '7ef20135cd182c3794c1ce9f7309b09804903171', "aria-label": this.messages.minute, "aria-valuemax": "12", "aria-valuemin": "1", "aria-valuenow": (minuteIsNumber && parseInt(this.minute)) || "0", "aria-valuetext": this.minute, class: {
+                [CSS.input]: true,
+                [CSS.minute]: true,
+                [CSS.inputFocus]: this.activeEl && this.activeEl === this.minuteEl,
+            }, onClick: this.inputClickHandler, onFocus: this.focusHandler, onKeyDown: this.minuteKeyDownHandler, role: "spinbutton", tabIndex: 0,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setMinuteEl }, this.localizedMinute || "--"), h("span", { key: '5c9f8d832d0e1e06b8f637fceaac7209aab6d58d', "aria-label": this.messages.minuteDown, class: {
+                [CSS.button]: true,
+                [CSS.buttonMinuteDown]: true,
+            }, onClick: this.minuteDownClickHandler, role: "button" }, h("calcite-icon", { key: 'ca3672e19d9dc9b9c4105144c5232d84b7489711', icon: "chevron-down", scale: iconScale }))), this.showSecond && h("span", { key: '5f484d639db6288275e213ceb5f0690a2752f618', class: CSS.delimiter }, this.localizedMinuteSuffix), this.showSecond && (h("div", { key: 'd52bb3a7fdfa867bbccbe78d3279fb0ceb76a88b', class: CSS.column, role: "group" }, h("span", { key: '28436193da89813ac7f018e9455241bf4e2d07d0', "aria-label": this.messages.secondUp, class: {
+                [CSS.button]: true,
+                [CSS.buttonSecondUp]: true,
+            }, onClick: this.secondUpClickHandler, role: "button" }, h("calcite-icon", { key: '839450a3d5330ba189d2d9e7ba66cf2618e632f2', icon: "chevron-up", scale: iconScale })), h("span", { key: '433feb864cc9f44ff7f6ffcaaef128f974a0634b', "aria-label": this.messages.second, "aria-valuemax": "59", "aria-valuemin": "0", "aria-valuenow": (secondIsNumber && parseInt(this.second)) || "0", "aria-valuetext": this.second, class: {
+                [CSS.input]: true,
+                [CSS.second]: true,
+                [CSS.inputFocus]: this.activeEl && this.activeEl === this.secondEl,
+            }, onClick: this.inputClickHandler, onFocus: this.focusHandler, onKeyDown: this.secondKeyDownHandler, role: "spinbutton", tabIndex: 0,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setSecondEl }, this.localizedSecond || "--"), h("span", { key: '808c3402b58419dd68e34274e560b670fdd1d1f0', "aria-label": this.messages.secondDown, class: {
+                [CSS.button]: true,
+                [CSS.buttonSecondDown]: true,
+            }, onClick: this.secondDownClickHandler, role: "button" }, h("calcite-icon", { key: 'f09e4ac46e13232647e49f9038475f797e215497', icon: "chevron-down", scale: iconScale })))), this.showFractionalSecond && (h("span", { key: 'f1043c1c34a7c9296994ff2cb63fb5b8f00a14b8', class: CSS.delimiter }, this.localizedDecimalSeparator)), this.showFractionalSecond && (h("div", { key: '9c19c935c10e46b54c60c02e701952bd398c7e33', class: CSS.column, role: "group" }, h("span", { key: '0f59c173041cfdf3820982e8d7dd8ed829a543ce', "aria-label": this.messages.fractionalSecondUp, class: {
+                [CSS.button]: true,
+                [CSS.buttonFractionalSecondUp]: true,
+            }, onClick: this.fractionalSecondUpClickHandler, role: "button" }, h("calcite-icon", { key: 'cd94cfecf478a52536c58252ead83ed41d65bb69', icon: "chevron-up", scale: iconScale })), h("span", { key: '0d494152f7b11714127f811e41c33d77010b2bbb', "aria-label": this.messages.fractionalSecond, "aria-valuemax": "999", "aria-valuemin": "1", "aria-valuenow": (fractionalSecondIsNumber && parseInt(this.fractionalSecond)) || "0", "aria-valuetext": this.localizedFractionalSecond, class: {
+                [CSS.input]: true,
+                [CSS.fractionalSecond]: true,
+                [CSS.inputFocus]: this.activeEl && this.activeEl === this.fractionalSecondEl,
+            }, onClick: this.inputClickHandler, onFocus: this.focusHandler, onKeyDown: this.fractionalSecondKeyDownHandler, role: "spinbutton", tabIndex: 0,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setFractionalSecondEl }, this.localizedFractionalSecond || "--"), h("span", { key: '424ee367ab5ee7c6715d32cff9edbc47e6c964a6', "aria-label": this.messages.fractionalSecondDown, class: {
+                [CSS.button]: true,
+                [CSS.buttonFractionalSecondDown]: true,
+            }, onClick: this.fractionalSecondDownClickHandler, role: "button" }, h("calcite-icon", { key: '91c71ca8891cb44a07a38cef3b144f170d1dc264', icon: "chevron-down", scale: iconScale })))), this.localizedSecondSuffix && (h("span", { key: '43066eb805fff853f88210ee4f17e2fbf5f9fb97', class: CSS.delimiter }, this.localizedSecondSuffix)), showMeridiem && (h("div", { key: '866b964e1e08c9b46d4e5a943a1471c767394ca9', class: {
+                [CSS.column]: true,
+                [CSS.meridiemStart]: this.meridiemOrder === 0,
+            }, role: "group" }, h("span", { key: '2b0046366a6784fa6ff99be3a3c5370b6a5c01d9', "aria-label": this.messages.meridiemUp, class: {
+                [CSS.button]: true,
+                [CSS.buttonMeridiemUp]: true,
+                [CSS.buttonTopRight]: true,
+            }, onClick: this.meridiemUpClickHandler, role: "button" }, h("calcite-icon", { key: '0c5fae03afd08adc4a3065ce595195610d23f96d', icon: "chevron-up", scale: iconScale })), h("span", { key: '148c4d7b777999d1fe2ca5937f16dfca61fcfd8c', "aria-label": this.messages.meridiem, "aria-valuemax": "2", "aria-valuemin": "1", "aria-valuenow": (this.meridiem === "PM" && "2") || "1", "aria-valuetext": this.meridiem, class: {
+                [CSS.input]: true,
+                [CSS.meridiem]: true,
+                [CSS.inputFocus]: this.activeEl && this.activeEl === this.meridiemEl,
+            }, onClick: this.inputClickHandler, onFocus: this.focusHandler, onKeyDown: this.meridiemKeyDownHandler, role: "spinbutton", tabIndex: 0,
+            // eslint-disable-next-line react/jsx-sort-props -- ref should be last so node attrs/props are in sync (see https://github.com/Esri/calcite-design-system/pull/6530)
+            ref: this.setMeridiemEl }, this.localizedMeridiem || "--"), h("span", { key: 'ee470559d0034555ba1f2a26199e54326d728b6a', "aria-label": this.messages.meridiemDown, class: {
+                [CSS.button]: true,
+                [CSS.buttonMeridiemDown]: true,
+                [CSS.buttonBottomRight]: true,
+            }, onClick: this.meridiemDownClickHandler, role: "button" }, h("calcite-icon", { key: '093408bb889d14238bfb2987db200e7d223addfa', icon: "chevron-down", scale: iconScale }))))));
+    }
+    static get delegatesFocus() { return true; }
+    static get assetsDirs() { return ["assets"]; }
+    get el() { return getElement(this); }
+    static get watchers() { return {
+        "step": ["stepChange"],
+        "value": ["valueWatcher"],
+        "messageOverrides": ["onMessagesChange"],
+        "effectiveLocale": ["effectiveLocaleWatcher"]
+    }; }
+};
+TimePicker.style = CalciteTimePickerStyle0;
+
+export { InputTimePicker as I, TimePicker as T, dayjs as d };
+
+//# sourceMappingURL=calcite-input-time-picker.calcite-time-picker-95823100.js.map