@bigbinary/neetoui 6.5.11-beta.1 → 6.5.12

package/dist/cjs/index-a780bb4a.js

@@ -0,0 +1,3841 @@
+'use strict';
+
+var _extends = require('./extends-1b35a664.js');
+var defineProperty = require('./defineProperty-ee86604b.js');
+var slicedToArray = require('./slicedToArray-732a2048.js');
+var objectWithoutProperties = require('./objectWithoutProperties-2fed2d7d.js');
+var React = require('react');
+var ReactDOM = require('react-dom');
+var index = require('./index-63580e68.js');
+var _commonjsHelpers = require('./_commonjsHelpers-44e4a143.js');
+var index$2 = require('./index-302c3d37.js');
+var index$1 = require('./index-68589e5c.js');
+var neetoCist = require('@bigbinary/neeto-cist');
+var Label = require('./Label.js');
+var useId = require('./useId-4e3deb5c.js');
+require('react-router-dom');
+require('./index-a8cc581e.js');
+require('./overlayManager.js');
+var neetoIcons = require('@bigbinary/neeto-icons');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+
+var customParseFormat$1 = {exports: {}};
+
+(function (module, exports) {
+	!function(e,t){module.exports=t();}(_commonjsHelpers.commonjsGlobal,(function(){var e={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"},t=/(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g,n=/\d\d/,r=/\d\d?/,i=/\d*[^-_:/,()\s\d]+/,o={},s=function(e){return (e=+e)+(e>68?1900:2e3)};var a=function(e){return function(t){this[e]=+t;}},f=[/[+-]\d\d:?(\d\d)?|Z/,function(e){(this.zone||(this.zone={})).offset=function(e){if(!e)return 0;if("Z"===e)return 0;var t=e.match(/([+-]|\d\d)/g),n=60*t[1]+(+t[2]||0);return 0===n?0:"+"===t[0]?-n:n}(e);}],h=function(e){var t=o[e];return t&&(t.indexOf?t:t.s.concat(t.f))},u=function(e,t){var n,r=o.meridiem;if(r){for(var i=1;i<=24;i+=1)if(e.indexOf(r(i,0,t))>-1){n=i>12;break}}else n=e===(t?"pm":"PM");return n},d={A:[i,function(e){this.afternoon=u(e,!1);}],a:[i,function(e){this.afternoon=u(e,!0);}],S:[/\d/,function(e){this.milliseconds=100*+e;}],SS:[n,function(e){this.milliseconds=10*+e;}],SSS:[/\d{3}/,function(e){this.milliseconds=+e;}],s:[r,a("seconds")],ss:[r,a("seconds")],m:[r,a("minutes")],mm:[r,a("minutes")],H:[r,a("hours")],h:[r,a("hours")],HH:[r,a("hours")],hh:[r,a("hours")],D:[r,a("day")],DD:[n,a("day")],Do:[i,function(e){var t=o.ordinal,n=e.match(/\d+/);if(this.day=n[0],t)for(var r=1;r<=31;r+=1)t(r).replace(/\[|\]/g,"")===e&&(this.day=r);}],M:[r,a("month")],MM:[n,a("month")],MMM:[i,function(e){var t=h("months"),n=(h("monthsShort")||t.map((function(e){return e.slice(0,3)}))).indexOf(e)+1;if(n<1)throw new Error;this.month=n%12||n;}],MMMM:[i,function(e){var t=h("months").indexOf(e)+1;if(t<1)throw new Error;this.month=t%12||t;}],Y:[/[+-]?\d+/,a("year")],YY:[n,function(e){this.year=s(e);}],YYYY:[/\d{4}/,a("year")],Z:f,ZZ:f};function c(n){var r,i;r=n,i=o&&o.formats;for(var s=(n=r.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(t,n,r){var o=r&&r.toUpperCase();return n||i[r]||e[r]||i[o].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(e,t,n){return t||n.slice(1)}))}))).match(t),a=s.length,f=0;f<a;f+=1){var h=s[f],u=d[h],c=u&&u[0],l=u&&u[1];s[f]=l?{regex:c,parser:l}:h.replace(/^\[|\]$/g,"");}return function(e){for(var t={},n=0,r=0;n<a;n+=1){var i=s[n];if("string"==typeof i)r+=i.length;else {var o=i.regex,f=i.parser,h=e.slice(r),u=o.exec(h)[0];f.call(t,u),e=e.replace(u,"");}}return function(e){var t=e.afternoon;if(void 0!==t){var n=e.hours;t?n<12&&(e.hours+=12):12===n&&(e.hours=0),delete e.afternoon;}}(t),t}}return function(e,t,n){n.p.customParseFormat=!0,e&&e.parseTwoDigitYear&&(s=e.parseTwoDigitYear);var r=t.prototype,i=r.parse;r.parse=function(e){var t=e.date,r=e.utc,s=e.args;this.$u=r;var a=s[1];if("string"==typeof a){var f=!0===s[2],h=!0===s[3],u=f||h,d=s[2];h&&(d=s[2]),o=this.$locale(),!f&&d&&(o=n.Ls[d]),this.$d=function(e,t,n){try{if(["x","X"].indexOf(t)>-1)return new Date(("X"===t?1e3:1)*e);var r=c(t)(e),i=r.year,o=r.month,s=r.day,a=r.hours,f=r.minutes,h=r.seconds,u=r.milliseconds,d=r.zone,l=new Date,m=s||(i||o?1:l.getDate()),M=i||l.getFullYear(),Y=0;i&&!o||(Y=o>0?o-1:l.getMonth());var p=a||0,v=f||0,D=h||0,g=u||0;return d?new Date(Date.UTC(M,Y,m,p,v,D,g+60*d.offset*1e3)):n?new Date(Date.UTC(M,Y,m,p,v,D,g)):new Date(M,Y,m,p,v,D,g)}catch(e){return new Date("")}}(t,a,r),this.init(),d&&!0!==d&&(this.$L=this.locale(d).$L),u&&t!=this.format(a)&&(this.$d=new Date("")),o={};}else if(a instanceof Array)for(var l=a.length,m=1;m<=l;m+=1){s[1]=a[m-1];var M=n.apply(this,s);if(M.isValid()){this.$d=M.$d,this.$L=M.$L,this.init();break}m===l&&(this.$d=new Date(""));}else i.call(this,e);};}}));
+} (customParseFormat$1));
+
+var customParseFormat = customParseFormat$1.exports;
+
+var __spreadArray$3 = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+// As defined on the list of supported events: https://reactjs.org/docs/events.html
+var clipboardEvents = ['onCopy', 'onCut', 'onPaste'];
+var compositionEvents = [
+    'onCompositionEnd',
+    'onCompositionStart',
+    'onCompositionUpdate',
+];
+var focusEvents = ['onFocus', 'onBlur'];
+var formEvents = ['onInput', 'onInvalid', 'onReset', 'onSubmit'];
+var imageEvents = ['onLoad', 'onError'];
+var keyboardEvents = ['onKeyDown', 'onKeyPress', 'onKeyUp'];
+var mediaEvents = [
+    'onAbort',
+    'onCanPlay',
+    'onCanPlayThrough',
+    'onDurationChange',
+    'onEmptied',
+    'onEncrypted',
+    'onEnded',
+    'onError',
+    'onLoadedData',
+    'onLoadedMetadata',
+    'onLoadStart',
+    'onPause',
+    'onPlay',
+    'onPlaying',
+    'onProgress',
+    'onRateChange',
+    'onSeeked',
+    'onSeeking',
+    'onStalled',
+    'onSuspend',
+    'onTimeUpdate',
+    'onVolumeChange',
+    'onWaiting',
+];
+var mouseEvents = [
+    'onClick',
+    'onContextMenu',
+    'onDoubleClick',
+    'onMouseDown',
+    'onMouseEnter',
+    'onMouseLeave',
+    'onMouseMove',
+    'onMouseOut',
+    'onMouseOver',
+    'onMouseUp',
+];
+var dragEvents = [
+    'onDrag',
+    'onDragEnd',
+    'onDragEnter',
+    'onDragExit',
+    'onDragLeave',
+    'onDragOver',
+    'onDragStart',
+    'onDrop',
+];
+var selectionEvents = ['onSelect'];
+var touchEvents = ['onTouchCancel', 'onTouchEnd', 'onTouchMove', 'onTouchStart'];
+var pointerEvents = [
+    'onPointerDown',
+    'onPointerMove',
+    'onPointerUp',
+    'onPointerCancel',
+    'onGotPointerCapture',
+    'onLostPointerCapture',
+    'onPointerEnter',
+    'onPointerLeave',
+    'onPointerOver',
+    'onPointerOut',
+];
+var uiEvents = ['onScroll'];
+var wheelEvents = ['onWheel'];
+var animationEvents = [
+    'onAnimationStart',
+    'onAnimationEnd',
+    'onAnimationIteration',
+];
+var transitionEvents = ['onTransitionEnd'];
+var otherEvents = ['onToggle'];
+var changeEvents = ['onChange'];
+var allEvents = __spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3(__spreadArray$3([], clipboardEvents, true), compositionEvents, true), focusEvents, true), formEvents, true), imageEvents, true), keyboardEvents, true), mediaEvents, true), mouseEvents, true), dragEvents, true), selectionEvents, true), touchEvents, true), pointerEvents, true), uiEvents, true), wheelEvents, true), animationEvents, true), transitionEvents, true), changeEvents, true), otherEvents, true);
+/**
+ * Returns an object with on-event callback props curried with provided args.
+ * @param {Object} props Props passed to a component.
+ * @param {Function=} getArgs A function that returns argument(s) on-event callbacks
+ *   shall be curried with.
+ */
+function makeEventProps(props, getArgs) {
+    var eventProps = {};
+    allEvents.forEach(function (eventName) {
+        var eventHandler = props[eventName];
+        if (!eventHandler) {
+            return;
+        }
+        if (getArgs) {
+            eventProps[eventName] = (function (event) {
+                return eventHandler(event, getArgs(eventName));
+            });
+        }
+        else {
+            eventProps[eventName] = eventHandler;
+        }
+    });
+    return eventProps;
+}
+
+function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e))for(t=0;t<e.length;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);else for(t in e)e[t]&&(n&&(n+=" "),n+=t);return n}function clsx(){for(var e,t,f=0,n="";f<arguments.length;)(e=arguments[f++])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
+
+/**
+ * Utils
+ */
+/**
+ * Gets hours from a given date.
+ *
+ * @param {Date | string} date Date to get hours from
+ * @returns {number} Hours
+ */
+function getHours(date) {
+    if (date instanceof Date) {
+        return date.getHours();
+    }
+    if (typeof date === 'string') {
+        var datePieces = date.split(':');
+        if (datePieces.length >= 2) {
+            var hoursString = datePieces[0];
+            if (hoursString) {
+                var hours = parseInt(hoursString, 10);
+                if (!isNaN(hours)) {
+                    return hours;
+                }
+            }
+        }
+    }
+    throw new Error("Failed to get hours from date: ".concat(date, "."));
+}
+/**
+ * Gets minutes from a given date.
+ *
+ * @param {Date | string} date Date to get minutes from
+ * @returns {number} Minutes
+ */
+function getMinutes(date) {
+    if (date instanceof Date) {
+        return date.getMinutes();
+    }
+    if (typeof date === 'string') {
+        var datePieces = date.split(':');
+        if (datePieces.length >= 2) {
+            var minutesString = datePieces[1] || '0';
+            var minutes = parseInt(minutesString, 10);
+            if (!isNaN(minutes)) {
+                return minutes;
+            }
+        }
+    }
+    throw new Error("Failed to get minutes from date: ".concat(date, "."));
+}
+/**
+ * Gets seconds from a given date.
+ *
+ * @param {Date | string} date Date to get seconds from
+ * @returns {number} Seconds
+ */
+function getSeconds(date) {
+    if (date instanceof Date) {
+        return date.getSeconds();
+    }
+    if (typeof date === 'string') {
+        var datePieces = date.split(':');
+        if (datePieces.length >= 2) {
+            var secondsWithMillisecondsString = datePieces[2] || '0';
+            var seconds = parseInt(secondsWithMillisecondsString, 10);
+            if (!isNaN(seconds)) {
+                return seconds;
+            }
+        }
+    }
+    throw new Error("Failed to get seconds from date: ".concat(date, "."));
+}
+/**
+ * Gets milliseconds from a given date.
+ *
+ * @param {Date | string} date Date to get milliseconds from
+ * @returns {number} Milliseconds
+ */
+function getMilliseconds(date) {
+    if (date instanceof Date) {
+        return date.getMilliseconds();
+    }
+    if (typeof date === 'string') {
+        var datePieces = date.split(':');
+        if (datePieces.length >= 2) {
+            var secondsWithMillisecondsString = datePieces[2] || '0';
+            var millisecondsString = secondsWithMillisecondsString.split('.')[1] || '0';
+            var milliseconds = parseInt(millisecondsString, 10);
+            if (!isNaN(milliseconds)) {
+                return milliseconds;
+            }
+        }
+    }
+    throw new Error("Failed to get seconds from date: ".concat(date, "."));
+}
+function padStart(num, val) {
+    if (val === void 0) { val = 2; }
+    var numStr = "".concat(num);
+    if (numStr.length >= val) {
+        return num;
+    }
+    return "0000".concat(numStr).slice(-val);
+}
+/**
+ * Returns local hours and minutes (hh:mm).
+ *
+ * @param {Date | string} date Date to get hours and minutes from
+ * @returns {string} Local hours and minutes
+ */
+function getHoursMinutes(date) {
+    var hours = padStart(getHours(date));
+    var minutes = padStart(getMinutes(date));
+    return "".concat(hours, ":").concat(minutes);
+}
+/**
+ * Returns local hours, minutes and seconds (hh:mm:ss).
+ *
+ * @param {Date | string} date Date to get hours, minutes and seconds from
+ * @returns {string} Local hours, minutes and seconds
+ */
+function getHoursMinutesSeconds(date) {
+    var hours = padStart(getHours(date));
+    var minutes = padStart(getMinutes(date));
+    var seconds = padStart(getSeconds(date));
+    return "".concat(hours, ":").concat(minutes, ":").concat(seconds);
+}
+
+function Hand(_a) {
+    var _b = _a.angle, angle = _b === void 0 ? 0 : _b, name = _a.name, _c = _a.length, length = _c === void 0 ? 100 : _c, _d = _a.oppositeLength, oppositeLength = _d === void 0 ? 10 : _d, _e = _a.width, width = _e === void 0 ? 1 : _e;
+    return (React__default["default"].createElement("div", { className: "react-clock__hand react-clock__".concat(name, "-hand"), style: {
+            transform: "rotate(".concat(angle, "deg)"),
+        } },
+        React__default["default"].createElement("div", { className: "react-clock__hand__body react-clock__".concat(name, "-hand__body"), style: {
+                width: "".concat(width, "px"),
+                top: "".concat(50 - length / 2, "%"),
+                bottom: "".concat(50 - oppositeLength / 2, "%"),
+            } })));
+}
+
+function Mark(_a) {
+    var _b = _a.angle, angle = _b === void 0 ? 0 : _b, _c = _a.length, length = _c === void 0 ? 10 : _c, name = _a.name, _d = _a.width, width = _d === void 0 ? 1 : _d, number = _a.number;
+    return (React__default["default"].createElement("div", { className: "react-clock__mark react-clock__".concat(name, "-mark"), style: {
+            transform: "rotate(".concat(angle, "deg)"),
+        } },
+        React__default["default"].createElement("div", { className: "react-clock__mark__body react-clock__".concat(name, "-mark__body"), style: {
+                width: "".concat(width, "px"),
+                top: 0,
+                bottom: "".concat(100 - length / 2, "%"),
+            } }),
+        number ? (React__default["default"].createElement("div", { className: "react-clock__mark__number", style: {
+                transform: "rotate(-".concat(angle, "deg)"),
+                top: "".concat(length / 2, "%"),
+            } }, number)) : null));
+}
+
+var __assign$e = (undefined && undefined.__assign) || function () {
+    __assign$e = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$e.apply(this, arguments);
+};
+var MinuteMark = React.memo(function MinuteMark(props) {
+    return React__default["default"].createElement(Mark, __assign$e({}, props));
+});
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/** `Object#toString` result references. */
+var funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]';
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal = typeof _commonjsHelpers.commonjsGlobal == 'object' && _commonjsHelpers.commonjsGlobal && _commonjsHelpers.commonjsGlobal.Object === Object && _commonjsHelpers.commonjsGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root = freeGlobal || freeSelf || Function('return this')();
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue(object, key) {
+  return object == null ? undefined : object[key];
+}
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+  // Many host objects are `Object` objects that can coerce to strings
+  // despite having improperly defined `toString` methods.
+  var result = false;
+  if (value != null && typeof value.toString != 'function') {
+    try {
+      result = !!(value + '');
+    } catch (e) {}
+  }
+  return result;
+}
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype,
+    funcProto = Function.prototype,
+    objectProto = Object.prototype;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData = root['__core-js_shared__'];
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? ('Symbol(src)_1.' + uid) : '';
+}());
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' +
+  funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&')
+  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+);
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/* Built-in method references that are verified to be native. */
+var Map$1 = getNative(root, 'Map'),
+    nativeCreate = getNative(Object, 'create');
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+  var index = -1,
+      length = entries ? entries.length : 0;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+}
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete(key) {
+  return this.has(key) && delete this.__data__[key];
+}
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED ? undefined : result;
+  }
+  return hasOwnProperty.call(data, key) ? data[key] : undefined;
+}
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet(key, value) {
+  var data = this.__data__;
+  data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+  return this;
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+  var index = -1,
+      length = entries ? entries.length : 0;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear() {
+  this.__data__ = [];
+}
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  return true;
+}
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet(key) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  return index < 0 ? undefined : data[index][1];
+}
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet(key, value) {
+  var data = this.__data__,
+      index = assocIndexOf(data, key);
+
+  if (index < 0) {
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+  var index = -1,
+      length = entries ? entries.length : 0;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear() {
+  this.__data__ = {
+    'hash': new Hash,
+    'map': new (Map$1 || ListCache),
+    'string': new Hash
+  };
+}
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete(key) {
+  return getMapData(this, key)['delete'](key);
+}
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet(key, value) {
+  getMapData(this, key).set(key, value);
+  return this;
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key)
+    ? data[typeof key == 'string' ? 'string' : 'hash']
+    : data.map;
+}
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable(value) {
+  var type = typeof value;
+  return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+    ? (value !== '__proto__')
+    : (value === null);
+}
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked(func) {
+  return !!maskSrcKey && (maskSrcKey in func);
+}
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to process.
+ * @returns {string} Returns the source code.
+ */
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString.call(func);
+    } catch (e) {}
+    try {
+      return (func + '');
+    } catch (e) {}
+  }
+  return '';
+}
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize(func, resolver) {
+  if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments,
+        key = resolver ? resolver.apply(this, args) : args[0],
+        cache = memoized.cache;
+
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result);
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache);
+  return memoized;
+}
+
+// Assign cache to `_.memoize`.
+memoize.Cache = MapCache;
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || (value !== value && other !== other);
+}
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 8-9 which returns 'object' for typed array and other constructors.
+  var tag = isObject(value) ? objectToString.call(value) : '';
+  return tag == funcTag || tag == genTag;
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return !!value && (type == 'object' || type == 'function');
+}
+
+var lodash_memoize = memoize;
+
+function resolver(options) {
+    return JSON.stringify(options);
+}
+function isString(el) {
+    return typeof el === 'string';
+}
+function isUnique(el, index, arr) {
+    return arr.indexOf(el) === index;
+}
+function isAllLowerCase(el) {
+    return el.toLowerCase() === el;
+}
+function fixCommas(el) {
+    return el.indexOf(',') === -1 ? el : el.split(',');
+}
+function normalizeLocale(locale) {
+    if (!locale) {
+        return locale;
+    }
+    if (locale === 'C' || locale === 'posix' || locale === 'POSIX') {
+        return 'en-US';
+    }
+    // If there's a dot (.) in the locale, it's likely in the format of "en-US.UTF-8", so we only take the first part
+    if (locale.indexOf('.') !== -1) {
+        var _a = locale.split('.')[0], actualLocale = _a === void 0 ? '' : _a;
+        return normalizeLocale(actualLocale);
+    }
+    // If there's an at sign (@) in the locale, it's likely in the format of "en-US@posix", so we only take the first part
+    if (locale.indexOf('@') !== -1) {
+        var _b = locale.split('@')[0], actualLocale = _b === void 0 ? '' : _b;
+        return normalizeLocale(actualLocale);
+    }
+    // If there's a dash (-) in the locale and it's not all lower case, it's already in the format of "en-US", so we return it
+    if (locale.indexOf('-') === -1 || !isAllLowerCase(locale)) {
+        return locale;
+    }
+    var _c = locale.split('-'), splitEl1 = _c[0], _d = _c[1], splitEl2 = _d === void 0 ? '' : _d;
+    return "".concat(splitEl1, "-").concat(splitEl2.toUpperCase());
+}
+function getUserLocalesInternal(_a) {
+    var _b = _a === void 0 ? {} : _a, _c = _b.useFallbackLocale, useFallbackLocale = _c === void 0 ? true : _c, _d = _b.fallbackLocale, fallbackLocale = _d === void 0 ? 'en-US' : _d;
+    var languageList = [];
+    if (typeof navigator !== 'undefined') {
+        var rawLanguages = navigator.languages || [];
+        var languages = [];
+        for (var _i = 0, rawLanguages_1 = rawLanguages; _i < rawLanguages_1.length; _i++) {
+            var rawLanguagesItem = rawLanguages_1[_i];
+            languages = languages.concat(fixCommas(rawLanguagesItem));
+        }
+        var rawLanguage = navigator.language;
+        var language = rawLanguage ? fixCommas(rawLanguage) : rawLanguage;
+        languageList = languageList.concat(languages, language);
+    }
+    if (useFallbackLocale) {
+        languageList.push(fallbackLocale);
+    }
+    return languageList.filter(isString).map(normalizeLocale).filter(isUnique);
+}
+var getUserLocales = lodash_memoize(getUserLocalesInternal, resolver);
+function getUserLocaleInternal(options) {
+    return getUserLocales(options)[0] || null;
+}
+var getUserLocale = lodash_memoize(getUserLocaleInternal, resolver);
+
+function formatHour(locale, hour) {
+    return hour.toLocaleString(locale || getUserLocale() || undefined);
+}
+
+var __assign$d = (undefined && undefined.__assign) || function () {
+    __assign$d = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$d.apply(this, arguments);
+};
+var __rest$b = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var HourMark = React.memo(function HourMark(_a) {
+    var _b = _a.formatHour, formatHour$1 = _b === void 0 ? formatHour : _b, locale = _a.locale, number = _a.number, otherProps = __rest$b(_a, ["formatHour", "locale", "number"]);
+    return React__default["default"].createElement(Mark, __assign$d({ number: number ? formatHour$1(locale, number) : null }, otherProps));
+});
+
+function isNumberBetween(min, max) {
+    return function (props, propName, componentName) {
+        var _a = props, _b = propName, value = _a[_b];
+        if (typeof value !== 'undefined') {
+            if (typeof value !== 'number') {
+                return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof value, "` supplied to `").concat(componentName, "`, expected `number`."));
+            }
+            if (value < min || value > max) {
+                return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof value, "` supplied to `").concat(componentName, "`, length must be between ").concat(min, " and ").concat(max, "."));
+            }
+        }
+        // Everything is fine
+        return null;
+    };
+}
+var isHandLength = isNumberBetween(0, 100);
+var isOppositeHandLength = isNumberBetween(-100, 100);
+var isHandWidth = function isHandWidth(props, propName, componentName) {
+    var _a = props, _b = propName, width = _a[_b];
+    if (typeof width !== 'undefined') {
+        if (typeof width !== 'number') {
+            return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof width, "` supplied to `").concat(componentName, "`, expected `number`."));
+        }
+        if (width < 0) {
+            return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof width, "` supplied to `").concat(componentName, "`, width must be greater or equal to 0."));
+        }
+    }
+    // Everything is fine
+    return null;
+};
+var isMarkLength = isHandLength;
+var isMarkWidth = isHandWidth;
+
+var Clock = function Clock(_a) {
+    var className = _a.className, formatHour = _a.formatHour, _b = _a.hourHandLength, hourHandLength = _b === void 0 ? 50 : _b, hourHandOppositeLength = _a.hourHandOppositeLength, _c = _a.hourHandWidth, hourHandWidth = _c === void 0 ? 4 : _c, _d = _a.hourMarksLength, hourMarksLength = _d === void 0 ? 10 : _d, _e = _a.hourMarksWidth, hourMarksWidth = _e === void 0 ? 3 : _e, locale = _a.locale, _f = _a.minuteHandLength, minuteHandLength = _f === void 0 ? 70 : _f, minuteHandOppositeLength = _a.minuteHandOppositeLength, _g = _a.minuteHandWidth, minuteHandWidth = _g === void 0 ? 2 : _g, _h = _a.minuteMarksLength, minuteMarksLength = _h === void 0 ? 6 : _h, _j = _a.minuteMarksWidth, minuteMarksWidth = _j === void 0 ? 1 : _j, _k = _a.renderHourMarks, renderHourMarks = _k === void 0 ? true : _k, _l = _a.renderMinuteHand, renderMinuteHand = _l === void 0 ? true : _l, _m = _a.renderMinuteMarks, renderMinuteMarks = _m === void 0 ? true : _m, renderNumbers = _a.renderNumbers, _o = _a.renderSecondHand, renderSecondHand = _o === void 0 ? true : _o, _p = _a.secondHandLength, secondHandLength = _p === void 0 ? 90 : _p, secondHandOppositeLength = _a.secondHandOppositeLength, _q = _a.secondHandWidth, secondHandWidth = _q === void 0 ? 1 : _q, _r = _a.size, size = _r === void 0 ? 150 : _r, useMillisecondPrecision = _a.useMillisecondPrecision, value = _a.value;
+    function renderMinuteMarksFn() {
+        if (!renderMinuteMarks) {
+            return null;
+        }
+        var minuteMarks = [];
+        for (var i = 1; i <= 60; i += 1) {
+            var isHourMark = renderHourMarks && !(i % 5);
+            if (!isHourMark) {
+                minuteMarks.push(React__default["default"].createElement(MinuteMark, { key: "minute_".concat(i), angle: i * 6, length: minuteMarksLength, name: "minute", width: minuteMarksWidth }));
+            }
+        }
+        return minuteMarks;
+    }
+    function renderHourMarksFn() {
+        if (!renderHourMarks) {
+            return null;
+        }
+        var hourMarks = [];
+        for (var i = 1; i <= 12; i += 1) {
+            hourMarks.push(React__default["default"].createElement(HourMark, { key: "hour_".concat(i), angle: i * 30, formatHour: formatHour, length: hourMarksLength, locale: locale, name: "hour", number: renderNumbers ? i : undefined, width: hourMarksWidth }));
+        }
+        return hourMarks;
+    }
+    function renderFace() {
+        return (React__default["default"].createElement("div", { className: "react-clock__face" },
+            renderMinuteMarksFn(),
+            renderHourMarksFn()));
+    }
+    function renderHourHandFn() {
+        var angle = value
+            ? getHours(value) * 30 +
+                getMinutes(value) / 2 +
+                getSeconds(value) / 120 +
+                (useMillisecondPrecision ? getMilliseconds(value) / 120000 : 0)
+            : 0;
+        return (React__default["default"].createElement(Hand, { angle: angle, length: hourHandLength, name: "hour", oppositeLength: hourHandOppositeLength, width: hourHandWidth }));
+    }
+    function renderMinuteHandFn() {
+        if (!renderMinuteHand) {
+            return null;
+        }
+        var angle = value
+            ? getHours(value) * 360 +
+                getMinutes(value) * 6 +
+                getSeconds(value) / 10 +
+                (useMillisecondPrecision ? getMilliseconds(value) / 10000 : 0)
+            : 0;
+        return (React__default["default"].createElement(Hand, { angle: angle, length: minuteHandLength, name: "minute", oppositeLength: minuteHandOppositeLength, width: minuteHandWidth }));
+    }
+    function renderSecondHandFn() {
+        if (!renderSecondHand) {
+            return null;
+        }
+        var angle = value
+            ? getMinutes(value) * 360 +
+                getSeconds(value) * 6 +
+                (useMillisecondPrecision ? getMilliseconds(value) * 0.006 : 0)
+            : 0;
+        return (React__default["default"].createElement(Hand, { angle: angle, length: secondHandLength, name: "second", oppositeLength: secondHandOppositeLength, width: secondHandWidth }));
+    }
+    return (React__default["default"].createElement("time", { className: clsx('react-clock', className), dateTime: value instanceof Date ? value.toISOString() : value || undefined, style: {
+            width: size,
+            height: size,
+        } },
+        renderFace(),
+        renderHourHandFn(),
+        renderMinuteHandFn(),
+        renderSecondHandFn()));
+};
+Clock.propTypes = {
+    className: index.propTypes.exports.oneOfType([index.propTypes.exports.string, index.propTypes.exports.arrayOf(index.propTypes.exports.string)]),
+    formatHour: index.propTypes.exports.func,
+    hourHandLength: isHandLength,
+    hourHandOppositeLength: isOppositeHandLength,
+    hourHandWidth: isHandWidth,
+    hourMarksLength: isMarkLength,
+    hourMarksWidth: isMarkWidth,
+    locale: index.propTypes.exports.string,
+    minuteHandLength: isHandLength,
+    minuteHandOppositeLength: isOppositeHandLength,
+    minuteHandWidth: isHandWidth,
+    minuteMarksLength: isMarkLength,
+    minuteMarksWidth: isMarkWidth,
+    renderHourMarks: index.propTypes.exports.bool,
+    renderMinuteHand: index.propTypes.exports.bool,
+    renderMinuteMarks: index.propTypes.exports.bool,
+    renderNumbers: index.propTypes.exports.bool,
+    renderSecondHand: index.propTypes.exports.bool,
+    secondHandLength: isHandLength,
+    secondHandOppositeLength: isOppositeHandLength,
+    secondHandWidth: isHandWidth,
+    size: index.propTypes.exports.oneOfType([index.propTypes.exports.number, index.propTypes.exports.string]),
+    value: index.propTypes.exports.oneOfType([index.propTypes.exports.string, index.propTypes.exports.instanceOf(Date)]),
+};
+
+function getRect(element) {
+    return element.getBoundingClientRect();
+}
+function detectElementOverflow(element, container) {
+    return {
+        get collidedTop() {
+            return getRect(element).top < getRect(container).top;
+        },
+        get collidedBottom() {
+            return getRect(element).bottom > getRect(container).bottom;
+        },
+        get collidedLeft() {
+            return getRect(element).left < getRect(container).left;
+        },
+        get collidedRight() {
+            return getRect(element).right > getRect(container).right;
+        },
+        get overflowTop() {
+            return getRect(container).top - getRect(element).top;
+        },
+        get overflowBottom() {
+            return getRect(element).bottom - getRect(container).bottom;
+        },
+        get overflowLeft() {
+            return getRect(container).left - getRect(element).left;
+        },
+        get overflowRight() {
+            return getRect(element).right - getRect(container).right;
+        },
+    };
+}
+
+var __extends = (undefined && undefined.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign$c = (undefined && undefined.__assign) || function () {
+    __assign$c = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$c.apply(this, arguments);
+};
+var __rest$a = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var isBrowser$4 = typeof document !== 'undefined';
+var isDisplayContentsSupported = isBrowser$4 && 'CSS' in window && 'supports' in window.CSS && CSS.supports('display', 'contents');
+var isMutationObserverSupported = isBrowser$4 && 'MutationObserver' in window;
+function capitalize(string) {
+    return (string.charAt(0).toUpperCase() + string.slice(1));
+}
+function findScrollContainer(element) {
+    var parent = element.parentElement;
+    while (parent) {
+        var overflow = window.getComputedStyle(parent).overflow;
+        if (overflow.split(' ').every(function (o) { return o === 'auto' || o === 'scroll'; })) {
+            return parent;
+        }
+        parent = parent.parentElement;
+    }
+    return document.documentElement;
+}
+function alignAxis(_a) {
+    var axis = _a.axis, container = _a.container, element = _a.element, invertAxis = _a.invertAxis, scrollContainer = _a.scrollContainer, secondary = _a.secondary, spacing = _a.spacing;
+    var style = window.getComputedStyle(element);
+    var parent = container.parentElement;
+    if (!parent) {
+        return;
+    }
+    var scrollContainerCollisions = detectElementOverflow(parent, scrollContainer);
+    var documentCollisions = detectElementOverflow(parent, document.documentElement);
+    var isX = axis === 'x';
+    var startProperty = isX ? 'left' : 'top';
+    var endProperty = isX ? 'right' : 'bottom';
+    var sizeProperty = isX ? 'width' : 'height';
+    var overflowStartProperty = "overflow".concat(capitalize(startProperty));
+    var overflowEndProperty = "overflow".concat(capitalize(endProperty));
+    var scrollProperty = "scroll".concat(capitalize(startProperty));
+    var uppercasedSizeProperty = capitalize(sizeProperty);
+    var offsetSizeProperty = "offset".concat(uppercasedSizeProperty);
+    var clientSizeProperty = "client".concat(uppercasedSizeProperty);
+    var minSizeProperty = "min-".concat(sizeProperty);
+    var scrollbarWidth = scrollContainer[offsetSizeProperty] - scrollContainer[clientSizeProperty];
+    var startSpacing = typeof spacing === 'object' ? spacing[startProperty] : spacing;
+    var availableStartSpace = -Math.max(scrollContainerCollisions[overflowStartProperty], documentCollisions[overflowStartProperty] + document.documentElement[scrollProperty]) - startSpacing;
+    var endSpacing = typeof spacing === 'object' ? spacing[endProperty] : spacing;
+    var availableEndSpace = -Math.max(scrollContainerCollisions[overflowEndProperty], documentCollisions[overflowEndProperty] - document.documentElement[scrollProperty]) -
+        endSpacing -
+        scrollbarWidth;
+    if (secondary) {
+        availableStartSpace += parent[clientSizeProperty];
+        availableEndSpace += parent[clientSizeProperty];
+    }
+    var offsetSize = element[offsetSizeProperty];
+    function displayStart() {
+        element.style[startProperty] = 'auto';
+        element.style[endProperty] = secondary ? '0' : '100%';
+    }
+    function displayEnd() {
+        element.style[startProperty] = secondary ? '0' : '100%';
+        element.style[endProperty] = 'auto';
+    }
+    function displayIfFits(availableSpace, display) {
+        var fits = offsetSize <= availableSpace;
+        if (fits) {
+            display();
+        }
+        return fits;
+    }
+    function displayStartIfFits() {
+        return displayIfFits(availableStartSpace, displayStart);
+    }
+    function displayEndIfFits() {
+        return displayIfFits(availableEndSpace, displayEnd);
+    }
+    function displayWhereverShrinkedFits() {
+        var moreSpaceStart = availableStartSpace > availableEndSpace;
+        var rawMinSize = style.getPropertyValue(minSizeProperty);
+        var minSize = rawMinSize ? parseInt(rawMinSize, 10) : null;
+        function shrinkToSize(size) {
+            var newSize = Math.max(size, minSize || 0);
+            element.style[sizeProperty] = "".concat(newSize, "px");
+        }
+        if (moreSpaceStart) {
+            shrinkToSize(availableStartSpace);
+            displayStart();
+        }
+        else {
+            shrinkToSize(availableEndSpace);
+            displayEnd();
+        }
+    }
+    var fits;
+    if (invertAxis) {
+        fits = displayStartIfFits() || displayEndIfFits();
+    }
+    else {
+        fits = displayEndIfFits() || displayStartIfFits();
+    }
+    if (!fits) {
+        displayWhereverShrinkedFits();
+    }
+}
+function alignMainAxis(args) {
+    alignAxis(args);
+}
+function alignSecondaryAxis(args) {
+    alignAxis(__assign$c(__assign$c({}, args), { axis: args.axis === 'x' ? 'y' : 'x', secondary: true }));
+}
+function alignBothAxis(args) {
+    var invertAxis = args.invertAxis, invertSecondaryAxis = args.invertSecondaryAxis, commonArgs = __rest$a(args, ["invertAxis", "invertSecondaryAxis"]);
+    alignMainAxis(__assign$c(__assign$c({}, commonArgs), { invertAxis: invertAxis }));
+    alignSecondaryAxis(__assign$c(__assign$c({}, commonArgs), { invertAxis: invertSecondaryAxis }));
+}
+var Fit = /** @class */ (function (_super) {
+    __extends(Fit, _super);
+    function Fit() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.fit = function () {
+            var _a = _this, scrollContainer = _a.scrollContainer, container = _a.container, element = _a.element;
+            if (!scrollContainer || !container || !element) {
+                return;
+            }
+            var elementWidth = element.clientWidth;
+            var elementHeight = element.clientHeight;
+            // No need to recalculate - already did that for current dimensions
+            if (_this.elementWidth === elementWidth && _this.elementHeight === elementHeight) {
+                return;
+            }
+            // Save the dimensions so that we know we don't need to repeat the function if unchanged
+            _this.elementWidth = elementWidth;
+            _this.elementHeight = elementHeight;
+            var parent = container.parentElement;
+            // Container was unmounted
+            if (!parent) {
+                return;
+            }
+            /**
+             * We need to ensure that <Fit />'s child has a absolute position. Otherwise,
+             * we wouldn't be able to place the child in the correct position.
+             */
+            var style = window.getComputedStyle(element);
+            var position = style.position;
+            if (position !== 'absolute') {
+                element.style.position = 'absolute';
+            }
+            /**
+             * We need to ensure that <Fit />'s parent has a relative or absolute position. Otherwise,
+             * we wouldn't be able to place the child in the correct position.
+             */
+            var parentStyle = window.getComputedStyle(parent);
+            var parentPosition = parentStyle.position;
+            if (parentPosition !== 'relative' && parentPosition !== 'absolute') {
+                parent.style.position = 'relative';
+            }
+            var _b = _this.props, invertAxis = _b.invertAxis, invertSecondaryAxis = _b.invertSecondaryAxis, _c = _b.mainAxis, mainAxis = _c === void 0 ? 'y' : _c, _d = _b.spacing, spacing = _d === void 0 ? 8 : _d;
+            alignBothAxis({
+                axis: mainAxis,
+                container: container,
+                element: element,
+                invertAxis: invertAxis,
+                invertSecondaryAxis: invertSecondaryAxis,
+                scrollContainer: scrollContainer,
+                spacing: spacing,
+            });
+        };
+        return _this;
+    }
+    Fit.prototype.componentDidMount = function () {
+        var _this = this;
+        if (!isDisplayContentsSupported) {
+            // eslint-disable-next-line react/no-find-dom-node
+            var element = ReactDOM.findDOMNode(this);
+            if (!element || !(element instanceof HTMLElement)) {
+                return;
+            }
+            this.container = element;
+            this.element = element;
+            this.scrollContainer = findScrollContainer(element);
+        }
+        this.fit();
+        var onMutation = function () {
+            _this.fit();
+        };
+        if (isMutationObserverSupported && this.element) {
+            var mutationObserver = new MutationObserver(onMutation);
+            mutationObserver.observe(this.element, {
+                attributes: true,
+                attributeFilter: ['class', 'style'],
+            });
+        }
+    };
+    Fit.prototype.render = function () {
+        var _this = this;
+        var children = this.props.children;
+        var child = React__default["default"].Children.only(children);
+        if (isDisplayContentsSupported) {
+            return (React__default["default"].createElement("span", { ref: function (container) {
+                    _this.container = container;
+                    var element = container && container.firstElementChild;
+                    if (!element || !(element instanceof HTMLElement)) {
+                        return;
+                    }
+                    _this.element = element;
+                    _this.scrollContainer = findScrollContainer(element);
+                }, style: { display: 'contents' } }, child));
+        }
+        return child;
+    };
+    Fit.propTypes = {
+        children: index.propTypes.exports.node.isRequired,
+        invertAxis: index.propTypes.exports.bool,
+        invertSecondaryAxis: index.propTypes.exports.bool,
+        mainAxis: index.propTypes.exports.oneOf(['x', 'y']),
+        spacing: index.propTypes.exports.oneOfType([
+            index.propTypes.exports.number,
+            index.propTypes.exports.shape({
+                bottom: index.propTypes.exports.number.isRequired,
+                left: index.propTypes.exports.number.isRequired,
+                right: index.propTypes.exports.number.isRequired,
+                top: index.propTypes.exports.number.isRequired,
+            }),
+        ]),
+    };
+    return Fit;
+}(React.Component));
+
+function Divider$1(_a) {
+    var children = _a.children;
+    return React__default["default"].createElement("span", { className: "react-time-picker__inputGroup__divider" }, children);
+}
+
+var allowedVariants = ['normal', 'small-caps'];
+/**
+ * Gets font CSS shorthand property given element.
+ *
+ * @param {HTMLElement} element Element to get font CSS shorthand property from
+ */
+function getFontShorthand(element) {
+    if (!element) {
+        return '';
+    }
+    var style = window.getComputedStyle(element);
+    if (style.font) {
+        return style.font;
+    }
+    var isFontDefined = style.fontFamily !== '';
+    if (!isFontDefined) {
+        return '';
+    }
+    var fontVariant = allowedVariants.includes(style.fontVariant) ? style.fontVariant : 'normal';
+    return "".concat(style.fontStyle, " ").concat(fontVariant, " ").concat(style.fontWeight, " ").concat(style.fontSize, " / ").concat(style.lineHeight, " ").concat(style.fontFamily);
+}
+var cachedCanvas;
+/**
+ * Measures text width given text and font CSS shorthand.
+ *
+ * @param {string} text Text to measure
+ * @param {string} font Font to use when measuring the text
+ */
+function measureText(text, font) {
+    var canvas = cachedCanvas || (cachedCanvas = document.createElement('canvas'));
+    var context = canvas.getContext('2d');
+    // Context type not supported
+    if (!context) {
+        return null;
+    }
+    context.font = font;
+    var width = context.measureText(text).width;
+    return Math.ceil(width);
+}
+/**
+ * Updates input element width to fit its content given input element
+ * @param {HTMLInputElement} element
+ */
+function updateInputWidth(element) {
+    if (typeof document === 'undefined' || !element) {
+        return null;
+    }
+    var font = getFontShorthand(element);
+    var text = element.value || element.placeholder;
+    var width = measureText(text, font);
+    if (width === null) {
+        return null;
+    }
+    element.style.width = "".concat(width, "px");
+    return width;
+}
+
+var isBrowser$3 = typeof document !== 'undefined';
+var useIsomorphicLayoutEffect$1 = isBrowser$3 ? React.useLayoutEffect : React.useEffect;
+var isIEOrEdgeLegacy$1 = isBrowser$3 && /(MSIE|Trident\/|Edge\/)/.test(navigator.userAgent);
+var isFirefox$1 = isBrowser$3 && /Firefox/.test(navigator.userAgent);
+function onFocus$1(event) {
+    var target = event.target;
+    if (isIEOrEdgeLegacy$1) {
+        requestAnimationFrame(function () { return target.select(); });
+    }
+    else {
+        target.select();
+    }
+}
+function updateInputWidthOnLoad$1(element) {
+    if (document.readyState === 'complete') {
+        return;
+    }
+    function onLoad() {
+        updateInputWidth(element);
+    }
+    window.addEventListener('load', onLoad);
+}
+function updateInputWidthOnFontLoad$1(element) {
+    if (!document.fonts) {
+        return;
+    }
+    var font = getFontShorthand(element);
+    if (!font) {
+        return;
+    }
+    var isFontLoaded = document.fonts.check(font);
+    if (isFontLoaded) {
+        return;
+    }
+    function onLoadingDone() {
+        updateInputWidth(element);
+    }
+    document.fonts.addEventListener('loadingdone', onLoadingDone);
+}
+function getSelectionString$1(input) {
+    /**
+     * window.getSelection().toString() returns empty string in IE11 and Firefox,
+     * so alternatives come first.
+     */
+    if (input &&
+        'selectionStart' in input &&
+        input.selectionStart !== null &&
+        'selectionEnd' in input &&
+        input.selectionEnd !== null) {
+        return input.value.slice(input.selectionStart, input.selectionEnd);
+    }
+    if ('getSelection' in window) {
+        var selection = window.getSelection();
+        return selection && selection.toString();
+    }
+    return null;
+}
+function makeOnKeyPress$1(maxLength) {
+    if (maxLength === null) {
+        return undefined;
+    }
+    /**
+     * Prevents keystrokes that would not produce a number or when value after keystroke would
+     * exceed maxLength.
+     */
+    return function onKeyPress(event) {
+        if (isFirefox$1) {
+            // See https://github.com/wojtekmaj/react-time-picker/issues/92
+            return;
+        }
+        var key = event.key, input = event.target;
+        var value = input.value;
+        var isNumberKey = key.length === 1 && /\d/.test(key);
+        var selection = getSelectionString$1(input);
+        if (!isNumberKey || !(selection || value.length < maxLength)) {
+            event.preventDefault();
+        }
+    };
+}
+function Input$1(_a) {
+    var ariaLabel = _a.ariaLabel, autoFocus = _a.autoFocus, className = _a.className, disabled = _a.disabled, inputRef = _a.inputRef, max = _a.max, min = _a.min, name = _a.name, nameForClass = _a.nameForClass, onChange = _a.onChange, onKeyDown = _a.onKeyDown, onKeyUp = _a.onKeyUp, _b = _a.placeholder, placeholder = _b === void 0 ? '--' : _b, required = _a.required, showLeadingZeros = _a.showLeadingZeros, step = _a.step, value = _a.value;
+    useIsomorphicLayoutEffect$1(function () {
+        if (!inputRef || !inputRef.current) {
+            return;
+        }
+        updateInputWidth(inputRef.current);
+        updateInputWidthOnLoad$1(inputRef.current);
+        updateInputWidthOnFontLoad$1(inputRef.current);
+    }, [inputRef, value]);
+    var hasLeadingZero = showLeadingZeros &&
+        value &&
+        Number(value) < 10 &&
+        (value === '0' || !value.toString().startsWith('0'));
+    var maxLength = max ? max.toString().length : null;
+    return (React__default["default"].createElement(React__default["default"].Fragment, null,
+        hasLeadingZero ? React__default["default"].createElement("span", { className: "".concat(className, "__leadingZero") }, "0") : null,
+        React__default["default"].createElement("input", { "aria-label": ariaLabel, autoComplete: "off", autoFocus: autoFocus, className: clsx("".concat(className, "__input"), "".concat(className, "__").concat(nameForClass || name), hasLeadingZero && "".concat(className, "__input--hasLeadingZero")), "data-input": "true", disabled: disabled, inputMode: "numeric", max: max, min: min, name: name, onChange: onChange, onFocus: onFocus$1, onKeyDown: onKeyDown, onKeyPress: makeOnKeyPress$1(maxLength), onKeyUp: function (event) {
+                updateInputWidth(event.target);
+                if (onKeyUp) {
+                    onKeyUp(event);
+                }
+            }, placeholder: placeholder, ref: inputRef, required: required, step: step, type: "number", value: value !== null ? value : '' })));
+}
+
+function convert12to24$1(hour12, amPm) {
+    var hour24 = Number(hour12);
+    if (amPm === 'am' && hour24 === 12) {
+        hour24 = 0;
+    }
+    else if (amPm === 'pm' && hour24 < 12) {
+        hour24 += 12;
+    }
+    return hour24;
+}
+function convert24to12$1(hour24) {
+    var hour12 = Number(hour24) % 12 || 12;
+    return [hour12, Number(hour24) < 12 ? 'am' : 'pm'];
+}
+
+var formatterCache$1 = new Map();
+function getFormatter$1(options) {
+    return function formatter(locale, date) {
+        var localeWithDefault = locale || getUserLocale();
+        if (!formatterCache$1.has(localeWithDefault)) {
+            formatterCache$1.set(localeWithDefault, new Map());
+        }
+        var formatterCacheLocale = formatterCache$1.get(localeWithDefault);
+        if (!formatterCacheLocale.has(options)) {
+            formatterCacheLocale.set(options, new Intl.DateTimeFormat(localeWithDefault || undefined, options).format);
+        }
+        return formatterCacheLocale.get(options)(date);
+    };
+}
+var numberFormatterCache$1 = new Map();
+function getNumberFormatter$1(options) {
+    return function (locale, number) {
+        var localeWithDefault = locale || getUserLocale();
+        if (!numberFormatterCache$1.has(localeWithDefault)) {
+            numberFormatterCache$1.set(localeWithDefault, new Map());
+        }
+        var numberFormatterCacheLocale = numberFormatterCache$1.get(localeWithDefault);
+        if (!numberFormatterCacheLocale.has(options)) {
+            numberFormatterCacheLocale.set(options, new Intl.NumberFormat(localeWithDefault || undefined, options).format);
+        }
+        return numberFormatterCacheLocale.get(options)(number);
+    };
+}
+
+var nines$1 = ['9', '٩'];
+var ninesRegExp$1 = new RegExp("[".concat(nines$1.join(''), "]"));
+var amPmFormatter$1 = getFormatter$1({ hour: 'numeric' });
+function getAmPmLabels$1(locale) {
+    var amString = amPmFormatter$1(locale, new Date(2017, 0, 1, 9));
+    var pmString = amPmFormatter$1(locale, new Date(2017, 0, 1, 21));
+    var _a = amString.split(ninesRegExp$1), am1 = _a[0], am2 = _a[1];
+    var _b = pmString.split(ninesRegExp$1), pm1 = _b[0], pm2 = _b[1];
+    if (pm2 !== undefined) {
+        // If pm2 is undefined, nine was not found in pmString - this locale is not using 12-hour time
+        if (am1 !== pm1) {
+            return [am1, pm1].map(function (el) { return el.trim(); });
+        }
+        if (am2 !== pm2) {
+            return [am2, pm2].map(function (el) { return el.trim(); });
+        }
+    }
+    // Fallback
+    return ['AM', 'PM'];
+}
+function isValidNumber$1(num) {
+    return num !== null && num !== false && !Number.isNaN(Number(num));
+}
+function safeMin$1() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return Math.min.apply(Math, args.filter(isValidNumber$1));
+}
+function safeMax$1() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return Math.max.apply(Math, args.filter(isValidNumber$1));
+}
+
+var __assign$b = (undefined && undefined.__assign) || function () {
+    __assign$b = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$b.apply(this, arguments);
+};
+var __rest$9 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function Hour12Input$1(_a) {
+    var amPm = _a.amPm, maxTime = _a.maxTime, minTime = _a.minTime, value = _a.value, otherProps = __rest$9(_a, ["amPm", "maxTime", "minTime", "value"]);
+    var maxHour = safeMin$1(12, maxTime &&
+        (function () {
+            var _a = convert24to12$1(getHours(maxTime)), maxHourResult = _a[0], maxAmPm = _a[1];
+            if (maxAmPm !== amPm) {
+                // pm is always after am, so we should ignore validation
+                return null;
+            }
+            return maxHourResult;
+        })());
+    var minHour = safeMax$1(1, minTime &&
+        (function () {
+            var _a = convert24to12$1(getHours(minTime)), minHourResult = _a[0], minAmPm = _a[1];
+            if (
+            // pm is always after am, so we should ignore validation
+            minAmPm !== amPm ||
+                // If minHour is 12 am/pm, user should be able to enter 12, 1, ..., 11.
+                minHourResult === 12) {
+                return null;
+            }
+            return minHourResult;
+        })());
+    var value12 = value ? convert24to12$1(value)[0].toString() : '';
+    return (React__default["default"].createElement(Input$1, __assign$b({ max: maxHour, min: minHour, name: "hour12", nameForClass: "hour", value: value12 }, otherProps)));
+}
+
+var __assign$a = (undefined && undefined.__assign) || function () {
+    __assign$a = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$a.apply(this, arguments);
+};
+var __rest$8 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function Hour24Input$1(_a) {
+    var maxTime = _a.maxTime, minTime = _a.minTime, otherProps = __rest$8(_a, ["maxTime", "minTime"]);
+    var maxHour = safeMin$1(23, maxTime && getHours(maxTime));
+    var minHour = safeMax$1(0, minTime && getHours(minTime));
+    return React__default["default"].createElement(Input$1, __assign$a({ max: maxHour, min: minHour, name: "hour24", nameForClass: "hour" }, otherProps));
+}
+
+var __assign$9 = (undefined && undefined.__assign) || function () {
+    __assign$9 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$9.apply(this, arguments);
+};
+var __rest$7 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function MinuteInput$1(_a) {
+    var hour = _a.hour, maxTime = _a.maxTime, minTime = _a.minTime, _b = _a.showLeadingZeros, showLeadingZeros = _b === void 0 ? true : _b, otherProps = __rest$7(_a, ["hour", "maxTime", "minTime", "showLeadingZeros"]);
+    function isSameHour(date) {
+        return hour === getHours(date).toString();
+    }
+    var maxMinute = safeMin$1(59, maxTime && isSameHour(maxTime) && getMinutes(maxTime));
+    var minMinute = safeMax$1(0, minTime && isSameHour(minTime) && getMinutes(minTime));
+    return (React__default["default"].createElement(Input$1, __assign$9({ max: maxMinute, min: minMinute, name: "minute", showLeadingZeros: showLeadingZeros }, otherProps)));
+}
+
+var __assign$8 = (undefined && undefined.__assign) || function () {
+    __assign$8 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$8.apply(this, arguments);
+};
+var __rest$6 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function SecondInput$1(_a) {
+    var hour = _a.hour, maxTime = _a.maxTime, minTime = _a.minTime, minute = _a.minute, _b = _a.showLeadingZeros, showLeadingZeros = _b === void 0 ? true : _b, otherProps = __rest$6(_a, ["hour", "maxTime", "minTime", "minute", "showLeadingZeros"]);
+    function isSameMinute(date) {
+        return hour === getHours(date).toString() && minute === getMinutes(date).toString();
+    }
+    var maxSecond = safeMin$1(59, maxTime && isSameMinute(maxTime) && getSeconds(maxTime));
+    var minSecond = safeMax$1(0, minTime && isSameMinute(minTime) && getSeconds(minTime));
+    return (React__default["default"].createElement(Input$1, __assign$8({ max: maxSecond, min: minSecond, name: "second", showLeadingZeros: showLeadingZeros }, otherProps)));
+}
+
+function NativeInput$1(_a) {
+    var ariaLabel = _a.ariaLabel, disabled = _a.disabled, maxTime = _a.maxTime, minTime = _a.minTime, name = _a.name, onChange = _a.onChange, required = _a.required, value = _a.value, valueType = _a.valueType;
+    var nativeValueParser = (function () {
+        switch (valueType) {
+            case 'hour':
+                return function (receivedValue) { return "".concat(getHours(receivedValue), ":00"); };
+            case 'minute':
+                return getHoursMinutes;
+            case 'second':
+                return getHoursMinutesSeconds;
+            default:
+                throw new Error('Invalid valueType');
+        }
+    })();
+    var step = (function () {
+        switch (valueType) {
+            case 'hour':
+                return 3600;
+            case 'minute':
+                return 60;
+            case 'second':
+                return 1;
+            default:
+                throw new Error('Invalid valueType');
+        }
+    })();
+    function stopPropagation(event) {
+        event.stopPropagation();
+    }
+    return (React__default["default"].createElement("input", { "aria-label": ariaLabel, disabled: disabled, hidden: true, max: maxTime ? nativeValueParser(maxTime) : undefined, min: minTime ? nativeValueParser(minTime) : undefined, name: name, onChange: onChange, onFocus: stopPropagation, required: required, step: step, style: {
+            visibility: 'hidden',
+            position: 'absolute',
+            zIndex: '-999',
+        }, type: "time", value: value ? nativeValueParser(value) : '' }));
+}
+
+function AmPm$1(_a) {
+    var ariaLabel = _a.ariaLabel, autoFocus = _a.autoFocus, className = _a.className, disabled = _a.disabled, inputRef = _a.inputRef, locale = _a.locale, maxTime = _a.maxTime, minTime = _a.minTime, onChange = _a.onChange, onKeyDown = _a.onKeyDown, required = _a.required, value = _a.value;
+    var amDisabled = minTime ? convert24to12$1(getHours(minTime))[1] === 'pm' : false;
+    var pmDisabled = maxTime ? convert24to12$1(getHours(maxTime))[1] === 'am' : false;
+    var name = 'amPm';
+    var _b = getAmPmLabels$1(locale), amLabel = _b[0], pmLabel = _b[1];
+    return (React__default["default"].createElement("select", { "aria-label": ariaLabel, autoFocus: autoFocus, className: clsx("".concat(className, "__input"), "".concat(className, "__").concat(name)), "data-input": "true", "data-select": "true", disabled: disabled, name: name, onChange: onChange, onKeyDown: onKeyDown, ref: inputRef, required: required, value: value !== null ? value : '' },
+        !value && React__default["default"].createElement("option", { value: "" }, "--"),
+        React__default["default"].createElement("option", { disabled: amDisabled, value: "am" }, amLabel),
+        React__default["default"].createElement("option", { disabled: pmDisabled, value: "pm" }, pmLabel)));
+}
+
+var __assign$7 = (undefined && undefined.__assign) || function () {
+    __assign$7 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$7.apply(this, arguments);
+};
+var __spreadArray$2 = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var getFormatterOptionsCache$1 = {};
+var allViews$4 = ['hour', 'minute', 'second'];
+function isInternalInput$1(element) {
+    return element.dataset.input === 'true';
+}
+function findInput$1(element, property) {
+    var nextElement = element;
+    do {
+        nextElement = nextElement[property];
+    } while (nextElement && !isInternalInput$1(nextElement));
+    return nextElement;
+}
+function focus$1(element) {
+    if (element) {
+        element.focus();
+    }
+}
+function renderCustomInputs$1(placeholder, elementFunctions, allowMultipleInstances) {
+    var usedFunctions = [];
+    var pattern = new RegExp(Object.keys(elementFunctions)
+        .map(function (el) { return "".concat(el, "+"); })
+        .join('|'), 'g');
+    var matches = placeholder.match(pattern);
+    return placeholder.split(pattern).reduce(function (arr, element, index) {
+        var divider = element && (
+        // eslint-disable-next-line react/no-array-index-key
+        React__default["default"].createElement(Divider$1, { key: "separator_".concat(index) }, element));
+        var res = __spreadArray$2(__spreadArray$2([], arr, true), [divider], false);
+        var currentMatch = matches && matches[index];
+        if (currentMatch) {
+            var renderFunction = elementFunctions[currentMatch] ||
+                elementFunctions[Object.keys(elementFunctions).find(function (elementFunction) {
+                    return currentMatch.match(elementFunction);
+                })];
+            if (!renderFunction) {
+                return res;
+            }
+            if (!allowMultipleInstances && usedFunctions.includes(renderFunction)) {
+                res.push(currentMatch);
+            }
+            else {
+                res.push(renderFunction(currentMatch, index));
+                usedFunctions.push(renderFunction);
+            }
+        }
+        return res;
+    }, []);
+}
+var formatNumber$1 = getNumberFormatter$1({ useGrouping: false });
+function TimeInput$1(_a) {
+    var amPmAriaLabel = _a.amPmAriaLabel, autoFocus = _a.autoFocus, className = _a.className, disabled = _a.disabled, format = _a.format, hourAriaLabel = _a.hourAriaLabel, hourPlaceholder = _a.hourPlaceholder, _b = _a.isClockOpen, isClockOpenProps = _b === void 0 ? null : _b, locale = _a.locale, _c = _a.maxDetail, maxDetail = _c === void 0 ? 'minute' : _c, maxTime = _a.maxTime, minTime = _a.minTime, minuteAriaLabel = _a.minuteAriaLabel, minutePlaceholder = _a.minutePlaceholder, _d = _a.name, name = _d === void 0 ? 'time' : _d, nativeInputAriaLabel = _a.nativeInputAriaLabel, onChangeProps = _a.onChange, onInvalidChange = _a.onInvalidChange, required = _a.required, secondAriaLabel = _a.secondAriaLabel, secondPlaceholder = _a.secondPlaceholder, valueProps = _a.value;
+    var _e = React.useState(null), amPm = _e[0], setAmPm = _e[1];
+    var _f = React.useState(null), hour = _f[0], setHour = _f[1];
+    var _g = React.useState(null), minute = _g[0], setMinute = _g[1];
+    var _h = React.useState(null), second = _h[0], setSecond = _h[1];
+    var _j = React.useState(null), value = _j[0], setValue = _j[1];
+    var amPmInput = React.useRef(null);
+    var hour12Input = React.useRef(null);
+    var hour24Input = React.useRef(null);
+    var minuteInput = React.useRef(null);
+    var secondInput = React.useRef(null);
+    var _k = React.useState(isClockOpenProps), isClockOpen = _k[0], setIsClockOpen = _k[1];
+    var lastPressedKey = React.useRef();
+    React.useEffect(function () {
+        setIsClockOpen(isClockOpenProps);
+    }, [isClockOpenProps]);
+    React.useEffect(function () {
+        var nextValue = valueProps;
+        if (nextValue) {
+            setAmPm(convert24to12$1(getHours(nextValue))[1]);
+            setHour(getHours(nextValue).toString());
+            setMinute(getMinutes(nextValue).toString());
+            setSecond(getSeconds(nextValue).toString());
+            setValue(nextValue);
+        }
+        else {
+            setAmPm(null);
+            setHour(null);
+            setMinute(null);
+            setSecond(null);
+            setValue(null);
+        }
+    }, [
+        valueProps,
+        minTime,
+        maxTime,
+        maxDetail,
+        // Toggling clock visibility resets values
+        isClockOpen,
+    ]);
+    var valueType = maxDetail;
+    var formatTime = (function () {
+        var level = allViews$4.indexOf(maxDetail);
+        var formatterOptions = getFormatterOptionsCache$1[level] ||
+            (function () {
+                var options = { hour: 'numeric' };
+                if (level >= 1) {
+                    options.minute = 'numeric';
+                }
+                if (level >= 2) {
+                    options.second = 'numeric';
+                }
+                getFormatterOptionsCache$1[level] = options;
+                return options;
+            })();
+        return getFormatter$1(formatterOptions);
+    })();
+    /**
+     * Gets current value in a desired format.
+     */
+    function getProcessedValue(value) {
+        var processFunction = (function () {
+            switch (valueType) {
+                case 'hour':
+                case 'minute':
+                    return getHoursMinutes;
+                case 'second':
+                    return getHoursMinutesSeconds;
+                default:
+                    throw new Error('Invalid valueType');
+            }
+        })();
+        return processFunction(value);
+    }
+    var placeholder = format ||
+        (function () {
+            var hour24 = 21;
+            var hour12 = 9;
+            var minute = 13;
+            var second = 14;
+            var date = new Date(2017, 0, 1, hour24, minute, second);
+            return formatTime(locale, date)
+                .replace(formatNumber$1(locale, hour12), 'h')
+                .replace(formatNumber$1(locale, hour24), 'H')
+                .replace(formatNumber$1(locale, minute), 'mm')
+                .replace(formatNumber$1(locale, second), 'ss')
+                .replace(new RegExp(getAmPmLabels$1(locale).join('|')), 'a');
+        })();
+    var divider = (function () {
+        var dividers = placeholder.match(/[^0-9a-z]/i);
+        return dividers ? dividers[0] : null;
+    })();
+    function onClick(event) {
+        if (event.target === event.currentTarget) {
+            // Wrapper was directly clicked
+            var firstInput = event.target.children[1];
+            focus$1(firstInput);
+        }
+    }
+    function onKeyDown(event) {
+        lastPressedKey.current = event.key;
+        switch (event.key) {
+            case 'ArrowLeft':
+            case 'ArrowRight':
+            case divider: {
+                event.preventDefault();
+                var input = event.target;
+                var property = event.key === 'ArrowLeft' ? 'previousElementSibling' : 'nextElementSibling';
+                var nextInput = findInput$1(input, property);
+                focus$1(nextInput);
+                break;
+            }
+        }
+    }
+    function onKeyUp(event) {
+        var key = event.key, input = event.target;
+        var isLastPressedKey = lastPressedKey.current === key;
+        if (!isLastPressedKey) {
+            return;
+        }
+        var isNumberKey = !isNaN(Number(key));
+        if (!isNumberKey) {
+            return;
+        }
+        var max = input.getAttribute('max');
+        if (!max) {
+            return;
+        }
+        var value = input.value;
+        /**
+         * Given 1, the smallest possible number the user could type by adding another digit is 10.
+         * 10 would be a valid value given max = 12, so we won't jump to the next input.
+         * However, given 2, smallers possible number would be 20, and thus keeping the focus in
+         * this field doesn't make sense.
+         */
+        if (Number(value) * 10 > Number(max) || value.length >= max.length) {
+            var property = 'nextElementSibling';
+            var nextInput = findInput$1(input, property);
+            focus$1(nextInput);
+        }
+    }
+    /**
+     * Called after internal onChange. Checks input validity. If all fields are valid,
+     * calls props.onChange.
+     */
+    function onChangeExternal() {
+        if (!onChangeProps) {
+            return;
+        }
+        function filterBoolean(value) {
+            return Boolean(value);
+        }
+        var formElements = [
+            amPmInput.current,
+            hour12Input.current,
+            hour24Input.current,
+            minuteInput.current,
+            secondInput.current,
+        ].filter(filterBoolean);
+        var formElementsWithoutSelect = formElements.slice(1);
+        var values = {};
+        formElements.forEach(function (formElement) {
+            values[formElement.name] =
+                formElement.type === 'number'
+                    ? 'valueAsNumber' in formElement
+                        ? formElement.valueAsNumber
+                        : Number(formElement.value)
+                    : formElement.value;
+        });
+        var isEveryValueEmpty = formElementsWithoutSelect.every(function (formElement) { return !formElement.value; });
+        if (isEveryValueEmpty) {
+            onChangeProps(null, false);
+            return;
+        }
+        var isEveryValueFilled = formElements.every(function (formElement) { return formElement.value; });
+        var isEveryValueValid = formElements.every(function (formElement) { return formElement.validity.valid; });
+        if (isEveryValueFilled && isEveryValueValid) {
+            var hour_1 = Number(values.hour24 ||
+                (values.hour12 && values.amPm && convert12to24$1(values.hour12, values.amPm)) ||
+                0);
+            var minute_1 = Number(values.minute || 0);
+            var second_1 = Number(values.second || 0);
+            var padStart = function (num) { return "0".concat(num).slice(-2); };
+            var proposedValue = "".concat(padStart(hour_1), ":").concat(padStart(minute_1), ":").concat(padStart(second_1));
+            var processedValue = getProcessedValue(proposedValue);
+            onChangeProps(processedValue, false);
+            return;
+        }
+        if (!onInvalidChange) {
+            return;
+        }
+        onInvalidChange();
+    }
+    /**
+     * Called when non-native date input is changed.
+     */
+    function onChange(event) {
+        var _a = event.target, name = _a.name, value = _a.value;
+        switch (name) {
+            case 'amPm':
+                setAmPm(value);
+                break;
+            case 'hour12':
+                setHour(value ? convert12to24$1(value, amPm || 'am').toString() : '');
+                break;
+            case 'hour24':
+                setHour(value);
+                break;
+            case 'minute':
+                setMinute(value);
+                break;
+            case 'second':
+                setSecond(value);
+                break;
+        }
+        onChangeExternal();
+    }
+    /**
+     * Called when native date input is changed.
+     */
+    function onChangeNative(event) {
+        var value = event.target.value;
+        if (!onChangeProps) {
+            return;
+        }
+        var processedValue = value || null;
+        onChangeProps(processedValue, false);
+    }
+    var commonInputProps = {
+        className: className,
+        disabled: disabled,
+        maxTime: maxTime,
+        minTime: minTime,
+        onChange: onChange,
+        onKeyDown: onKeyDown,
+        onKeyUp: onKeyUp,
+        // This is only for showing validity when editing
+        required: Boolean(required || isClockOpen),
+    };
+    function renderHour12(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : false;
+        return (React__default["default"].createElement(Hour12Input$1, __assign$7({ key: "hour12" }, commonInputProps, { amPm: amPm, ariaLabel: hourAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, inputRef: hour12Input, placeholder: hourPlaceholder, showLeadingZeros: showLeadingZeros, value: hour })));
+    }
+    function renderHour24(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : false;
+        return (React__default["default"].createElement(Hour24Input$1, __assign$7({ key: "hour24" }, commonInputProps, { ariaLabel: hourAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, inputRef: hour24Input, placeholder: hourPlaceholder, showLeadingZeros: showLeadingZeros, value: hour })));
+    }
+    function renderHour(currentMatch, index) {
+        if (/h/.test(currentMatch)) {
+            return renderHour12(currentMatch, index);
+        }
+        return renderHour24(currentMatch, index);
+    }
+    function renderMinute(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : false;
+        return (React__default["default"].createElement(MinuteInput$1, __assign$7({ key: "minute" }, commonInputProps, { ariaLabel: minuteAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, hour: hour, inputRef: minuteInput, placeholder: minutePlaceholder, showLeadingZeros: showLeadingZeros, value: minute })));
+    }
+    function renderSecond(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : true;
+        return (React__default["default"].createElement(SecondInput$1, __assign$7({ key: "second" }, commonInputProps, { ariaLabel: secondAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, hour: hour, inputRef: secondInput, minute: minute, placeholder: secondPlaceholder, showLeadingZeros: showLeadingZeros, value: second })));
+    }
+    function renderAmPm(currentMatch, index) {
+        return (React__default["default"].createElement(AmPm$1, __assign$7({ key: "ampm" }, commonInputProps, { ariaLabel: amPmAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, inputRef: amPmInput, locale: locale, onChange: onChange, value: amPm })));
+    }
+    function renderCustomInputsInternal() {
+        var elementFunctions = {
+            h: renderHour,
+            H: renderHour,
+            m: renderMinute,
+            s: renderSecond,
+            a: renderAmPm,
+        };
+        var allowMultipleInstances = typeof format !== 'undefined';
+        return renderCustomInputs$1(placeholder, elementFunctions, allowMultipleInstances);
+    }
+    function renderNativeInput() {
+        return (React__default["default"].createElement(NativeInput$1, { key: "time", ariaLabel: nativeInputAriaLabel, disabled: disabled, maxTime: maxTime, minTime: minTime, name: name, onChange: onChangeNative, required: required, value: value, valueType: valueType }));
+    }
+    return (
+    // eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions
+    React__default["default"].createElement("div", { className: className, onClick: onClick },
+        renderNativeInput(),
+        renderCustomInputsInternal()));
+}
+
+var hourOptionalSecondsRegExp$1 = /^(([0-1])?[0-9]|2[0-3]):[0-5][0-9](:([0-5][0-9]))?$/;
+var isTime$1 = function isTime(props, propName, componentName) {
+    var _a = props, _b = propName, time = _a[_b];
+    if (time) {
+        if (typeof time !== 'string' || !hourOptionalSecondsRegExp$1.test(time)) {
+            return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof time, "` supplied to `").concat(componentName, "`, expected time in HH:mm(:ss) format."));
+        }
+    }
+    // Everything is fine
+    return null;
+};
+var rangeOf$1 = function (type) {
+    return index.propTypes.exports.arrayOf(type);
+};
+
+var __assign$6 = (undefined && undefined.__assign) || function () {
+    __assign$6 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$6.apply(this, arguments);
+};
+var __rest$5 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var isBrowser$2 = typeof document !== 'undefined';
+var baseClassName$1 = 'react-timerange-picker';
+var outsideActionEvents$1 = ['mousedown', 'focusin', 'touchstart'];
+var allViews$3 = ['hour', 'minute', 'second'];
+var iconProps$1 = {
+    xmlns: 'http://www.w3.org/2000/svg',
+    width: 19,
+    height: 19,
+    viewBox: '0 0 19 19',
+    stroke: 'black',
+    strokeWidth: 2,
+};
+var ClockIcon$1 = (React__default["default"].createElement("svg", __assign$6({}, iconProps$1, { className: "".concat(baseClassName$1, "__clock-button__icon ").concat(baseClassName$1, "__button__icon"), fill: "none" }),
+    React__default["default"].createElement("circle", { cx: "9.5", cy: "9.5", r: "7.5" }),
+    React__default["default"].createElement("path", { d: "M9.5 4.5 v5 h4" })));
+var ClearIcon$1 = (React__default["default"].createElement("svg", __assign$6({}, iconProps$1, { className: "".concat(baseClassName$1, "__clear-button__icon ").concat(baseClassName$1, "__button__icon") }),
+    React__default["default"].createElement("line", { x1: "4", x2: "15", y1: "4", y2: "15" }),
+    React__default["default"].createElement("line", { x1: "15", x2: "4", y1: "4", y2: "15" })));
+var TimeRangePicker = function TimeRangePicker(props) {
+    var amPmAriaLabel = props.amPmAriaLabel, autoFocus = props.autoFocus, className = props.className, clearAriaLabel = props.clearAriaLabel, _a = props.clearIcon, clearIcon = _a === void 0 ? ClearIcon$1 : _a, clockAriaLabel = props.clockAriaLabel, _b = props.clockIcon, clockIcon = _b === void 0 ? ClockIcon$1 : _b, _c = props.closeClock, shouldCloseClockOnSelect = _c === void 0 ? true : _c, dataTestid = props["data-testid"], disableClock = props.disableClock, disabled = props.disabled, format = props.format, hourAriaLabel = props.hourAriaLabel, hourPlaceholder = props.hourPlaceholder, id = props.id, _d = props.isOpen, isOpenProps = _d === void 0 ? null : _d, locale = props.locale, _e = props.maxDetail, maxDetail = _e === void 0 ? 'minute' : _e, maxTime = props.maxTime, minTime = props.minTime, minuteAriaLabel = props.minuteAriaLabel, minutePlaceholder = props.minutePlaceholder, _f = props.name, name = _f === void 0 ? 'timerange' : _f, nativeInputAriaLabel = props.nativeInputAriaLabel, onChangeProps = props.onChange, onClockClose = props.onClockClose, onClockOpen = props.onClockOpen, onFocusProps = props.onFocus, onInvalidChange = props.onInvalidChange, _g = props.openClockOnFocus, openClockOnFocus = _g === void 0 ? true : _g, _h = props.rangeDivider, rangeDivider = _h === void 0 ? '–' : _h, required = props.required, secondAriaLabel = props.secondAriaLabel, secondPlaceholder = props.secondPlaceholder, shouldCloseClock = props.shouldCloseClock, shouldOpenClock = props.shouldOpenClock, value = props.value, otherProps = __rest$5(props, ["amPmAriaLabel", "autoFocus", "className", "clearAriaLabel", "clearIcon", "clockAriaLabel", "clockIcon", "closeClock", 'data-testid', "disableClock", "disabled", "format", "hourAriaLabel", "hourPlaceholder", "id", "isOpen", "locale", "maxDetail", "maxTime", "minTime", "minuteAriaLabel", "minutePlaceholder", "name", "nativeInputAriaLabel", "onChange", "onClockClose", "onClockOpen", "onFocus", "onInvalidChange", "openClockOnFocus", "rangeDivider", "required", "secondAriaLabel", "secondPlaceholder", "shouldCloseClock", "shouldOpenClock", "value"]);
+    var _j = React.useState(isOpenProps), isOpen = _j[0], setIsOpen = _j[1];
+    var wrapper = React.useRef(null);
+    var clockWrapper = React.useRef(null);
+    React.useEffect(function () {
+        setIsOpen(isOpenProps);
+    }, [isOpenProps]);
+    function openClock(_a) {
+        var reason = _a.reason;
+        if (shouldOpenClock) {
+            if (!shouldOpenClock({ reason: reason })) {
+                return;
+            }
+        }
+        setIsOpen(true);
+        if (onClockOpen) {
+            onClockOpen();
+        }
+    }
+    var closeClock = React.useCallback(function (_a) {
+        var reason = _a.reason;
+        if (shouldCloseClock) {
+            if (!shouldCloseClock({ reason: reason })) {
+                return;
+            }
+        }
+        setIsOpen(false);
+        if (onClockClose) {
+            onClockClose();
+        }
+    }, [onClockClose, shouldCloseClock]);
+    function toggleClock() {
+        if (isOpen) {
+            closeClock({ reason: 'buttonClick' });
+        }
+        else {
+            openClock({ reason: 'buttonClick' });
+        }
+    }
+    function onChange(value, shouldCloseClock) {
+        if (shouldCloseClock === void 0) { shouldCloseClock = shouldCloseClockOnSelect; }
+        if (shouldCloseClock) {
+            closeClock({ reason: 'select' });
+        }
+        if (onChangeProps) {
+            onChangeProps(value);
+        }
+    }
+    function onChangeFrom(valueFrom, closeClock) {
+        var _a = Array.isArray(value) ? value : [value], valueTo = _a[1];
+        onChange([valueFrom, valueTo || null], closeClock);
+    }
+    function onChangeTo(valueTo, closeClock) {
+        var valueFrom = (Array.isArray(value) ? value : [value])[0];
+        onChange([valueFrom || null, valueTo], closeClock);
+    }
+    function onFocus(event) {
+        if (onFocusProps) {
+            onFocusProps(event);
+        }
+        if (
+        // Internet Explorer still fires onFocus on disabled elements
+        disabled ||
+            isOpen ||
+            !openClockOnFocus ||
+            event.target.dataset.select === 'true') {
+            return;
+        }
+        openClock({ reason: 'focus' });
+    }
+    var onKeyDown = React.useCallback(function (event) {
+        if (event.key === 'Escape') {
+            closeClock({ reason: 'escape' });
+        }
+    }, [closeClock]);
+    function clear() {
+        onChange(null);
+    }
+    function stopPropagation(event) {
+        event.stopPropagation();
+    }
+    var onOutsideAction = React.useCallback(function (event) {
+        var wrapperEl = wrapper.current;
+        var clockWrapperEl = clockWrapper.current;
+        // Try event.composedPath first to handle clicks inside a Shadow DOM.
+        var target = ('composedPath' in event ? event.composedPath()[0] : event.target);
+        if (target &&
+            wrapperEl &&
+            !wrapperEl.contains(target) &&
+            (!clockWrapperEl || !clockWrapperEl.contains(target))) {
+            closeClock({ reason: 'outsideAction' });
+        }
+    }, [clockWrapper, closeClock, wrapper]);
+    var handleOutsideActionListeners = React.useCallback(function (shouldListen) {
+        if (shouldListen === void 0) { shouldListen = isOpen; }
+        outsideActionEvents$1.forEach(function (event) {
+            if (shouldListen) {
+                document.addEventListener(event, onOutsideAction);
+            }
+            else {
+                document.removeEventListener(event, onOutsideAction);
+            }
+        });
+        if (shouldListen) {
+            document.addEventListener('keydown', onKeyDown);
+        }
+        else {
+            document.removeEventListener('keydown', onKeyDown);
+        }
+    }, [isOpen, onOutsideAction, onKeyDown]);
+    React.useEffect(function () {
+        handleOutsideActionListeners();
+        return function () {
+            handleOutsideActionListeners(false);
+        };
+    }, [handleOutsideActionListeners, isOpen]);
+    function renderInputs() {
+        var _a = Array.isArray(value) ? value : [value], valueFrom = _a[0], valueTo = _a[1];
+        var ariaLabelProps = {
+            amPmAriaLabel: amPmAriaLabel,
+            hourAriaLabel: hourAriaLabel,
+            minuteAriaLabel: minuteAriaLabel,
+            nativeInputAriaLabel: nativeInputAriaLabel,
+            secondAriaLabel: secondAriaLabel,
+        };
+        var placeholderProps = {
+            hourPlaceholder: hourPlaceholder,
+            minutePlaceholder: minutePlaceholder,
+            secondPlaceholder: secondPlaceholder,
+        };
+        var commonProps = __assign$6(__assign$6(__assign$6({}, ariaLabelProps), placeholderProps), { className: "".concat(baseClassName$1, "__inputGroup"), disabled: disabled, format: format, isClockOpen: isOpen, locale: locale, maxDetail: maxDetail, maxTime: maxTime, minTime: minTime, onInvalidChange: onInvalidChange, required: required });
+        return (React__default["default"].createElement("div", { className: "".concat(baseClassName$1, "__wrapper") },
+            React__default["default"].createElement(TimeInput$1, __assign$6({}, commonProps, { 
+                // eslint-disable-next-line jsx-a11y/no-autofocus
+                autoFocus: autoFocus, name: "".concat(name, "_from"), onChange: onChangeFrom, value: valueFrom })),
+            React__default["default"].createElement("span", { className: "".concat(baseClassName$1, "__range-divider") }, rangeDivider),
+            React__default["default"].createElement(TimeInput$1, __assign$6({}, commonProps, { name: "".concat(name, "_to"), onChange: onChangeTo, value: valueTo })),
+            clearIcon !== null && (React__default["default"].createElement("button", { "aria-label": clearAriaLabel, className: "".concat(baseClassName$1, "__clear-button ").concat(baseClassName$1, "__button"), disabled: disabled, onClick: clear, onFocus: stopPropagation, type: "button" }, typeof clearIcon === 'function' ? React__default["default"].createElement(clearIcon) : clearIcon)),
+            clockIcon !== null && !disableClock && (React__default["default"].createElement("button", { "aria-label": clockAriaLabel, className: "".concat(baseClassName$1, "__clock-button ").concat(baseClassName$1, "__button"), disabled: disabled, onClick: toggleClock, onFocus: stopPropagation, type: "button" }, typeof clockIcon === 'function' ? React__default["default"].createElement(clockIcon) : clockIcon))));
+    }
+    function renderClock() {
+        if (isOpen === null || disableClock) {
+            return null;
+        }
+        var clockClassName = props.clockClassName; props.className; // Unused, here to exclude it from clockProps
+        props.onChange; // Unused, here to exclude it from clockProps
+        var portalContainer = props.portalContainer, value = props.value, clockProps = __rest$5(props, ["clockClassName", "className", "onChange", "portalContainer", "value"]);
+        var className = "".concat(baseClassName$1, "__clock");
+        var classNames = clsx(className, "".concat(className, "--").concat(isOpen ? 'open' : 'closed'));
+        var valueFrom = (Array.isArray(value) ? value : [value])[0];
+        var clock = React__default["default"].createElement(Clock, __assign$6({ className: clockClassName, value: valueFrom }, clockProps));
+        return portalContainer ? (ReactDOM.createPortal(React__default["default"].createElement("div", { ref: clockWrapper, className: classNames }, clock), portalContainer)) : (React__default["default"].createElement(Fit, null,
+            React__default["default"].createElement("div", { ref: function (ref) {
+                    if (ref && !isOpen) {
+                        ref.removeAttribute('style');
+                    }
+                }, className: classNames }, clock)));
+    }
+    var eventProps = React.useMemo(function () { return makeEventProps(otherProps); }, [otherProps]);
+    return (React__default["default"].createElement("div", __assign$6({ className: clsx(baseClassName$1, "".concat(baseClassName$1, "--").concat(isOpen ? 'open' : 'closed'), "".concat(baseClassName$1, "--").concat(disabled ? 'disabled' : 'enabled'), className), "data-testid": dataTestid, id: id }, eventProps, { onFocus: onFocus, ref: wrapper }),
+        renderInputs(),
+        renderClock()));
+};
+var isValue$1 = index.propTypes.exports.oneOfType([index.propTypes.exports.string, index.propTypes.exports.instanceOf(Date)]);
+var isValueOrValueArray$1 = index.propTypes.exports.oneOfType([isValue$1, rangeOf$1(isValue$1)]);
+TimeRangePicker.propTypes = {
+    amPmAriaLabel: index.propTypes.exports.string,
+    autoFocus: index.propTypes.exports.bool,
+    className: index.propTypes.exports.oneOfType([index.propTypes.exports.string, index.propTypes.exports.arrayOf(index.propTypes.exports.string)]),
+    clearAriaLabel: index.propTypes.exports.string,
+    clearIcon: index.propTypes.exports.oneOfType([index.propTypes.exports.node, index.propTypes.exports.func]),
+    clockAriaLabel: index.propTypes.exports.string,
+    clockClassName: index.propTypes.exports.oneOfType([index.propTypes.exports.string, index.propTypes.exports.arrayOf(index.propTypes.exports.string)]),
+    clockIcon: index.propTypes.exports.oneOfType([index.propTypes.exports.node, index.propTypes.exports.func]),
+    closeClock: index.propTypes.exports.bool,
+    'data-testid': index.propTypes.exports.string,
+    disableClock: index.propTypes.exports.bool,
+    disabled: index.propTypes.exports.bool,
+    format: index.propTypes.exports.string,
+    hourAriaLabel: index.propTypes.exports.string,
+    hourPlaceholder: index.propTypes.exports.string,
+    id: index.propTypes.exports.string,
+    isOpen: index.propTypes.exports.bool,
+    locale: index.propTypes.exports.string,
+    maxDetail: index.propTypes.exports.oneOf(allViews$3),
+    maxTime: isTime$1,
+    minTime: isTime$1,
+    minuteAriaLabel: index.propTypes.exports.string,
+    minutePlaceholder: index.propTypes.exports.string,
+    name: index.propTypes.exports.string,
+    nativeInputAriaLabel: index.propTypes.exports.string,
+    onChange: index.propTypes.exports.func,
+    onClockClose: index.propTypes.exports.func,
+    onClockOpen: index.propTypes.exports.func,
+    onFocus: index.propTypes.exports.func,
+    openClockOnFocus: index.propTypes.exports.bool,
+    rangeDivider: index.propTypes.exports.node,
+    required: index.propTypes.exports.bool,
+    secondAriaLabel: index.propTypes.exports.string,
+    secondPlaceholder: index.propTypes.exports.string,
+    value: isValueOrValueArray$1,
+};
+if (isBrowser$2) {
+    TimeRangePicker.propTypes.portalContainer = index.propTypes.exports.instanceOf(HTMLElement);
+}
+
+function Divider(_a) {
+    var children = _a.children;
+    return React__default["default"].createElement("span", { className: "react-time-picker__inputGroup__divider" }, children);
+}
+
+var isBrowser$1 = typeof document !== 'undefined';
+var useIsomorphicLayoutEffect = isBrowser$1 ? React.useLayoutEffect : React.useEffect;
+var isIEOrEdgeLegacy = isBrowser$1 && /(MSIE|Trident\/|Edge\/)/.test(navigator.userAgent);
+var isFirefox = isBrowser$1 && /Firefox/.test(navigator.userAgent);
+function onFocus(event) {
+    var target = event.target;
+    if (isIEOrEdgeLegacy) {
+        requestAnimationFrame(function () { return target.select(); });
+    }
+    else {
+        target.select();
+    }
+}
+function updateInputWidthOnLoad(element) {
+    if (document.readyState === 'complete') {
+        return;
+    }
+    function onLoad() {
+        updateInputWidth(element);
+    }
+    window.addEventListener('load', onLoad);
+}
+function updateInputWidthOnFontLoad(element) {
+    if (!document.fonts) {
+        return;
+    }
+    var font = getFontShorthand(element);
+    if (!font) {
+        return;
+    }
+    var isFontLoaded = document.fonts.check(font);
+    if (isFontLoaded) {
+        return;
+    }
+    function onLoadingDone() {
+        updateInputWidth(element);
+    }
+    document.fonts.addEventListener('loadingdone', onLoadingDone);
+}
+function getSelectionString(input) {
+    /**
+     * window.getSelection().toString() returns empty string in IE11 and Firefox,
+     * so alternatives come first.
+     */
+    if (input &&
+        'selectionStart' in input &&
+        input.selectionStart !== null &&
+        'selectionEnd' in input &&
+        input.selectionEnd !== null) {
+        return input.value.slice(input.selectionStart, input.selectionEnd);
+    }
+    if ('getSelection' in window) {
+        var selection = window.getSelection();
+        return selection && selection.toString();
+    }
+    return null;
+}
+function makeOnKeyPress(maxLength) {
+    if (maxLength === null) {
+        return undefined;
+    }
+    /**
+     * Prevents keystrokes that would not produce a number or when value after keystroke would
+     * exceed maxLength.
+     */
+    return function onKeyPress(event) {
+        if (isFirefox) {
+            // See https://github.com/wojtekmaj/react-time-picker/issues/92
+            return;
+        }
+        var key = event.key, input = event.target;
+        var value = input.value;
+        var isNumberKey = key.length === 1 && /\d/.test(key);
+        var selection = getSelectionString(input);
+        if (!isNumberKey || !(selection || value.length < maxLength)) {
+            event.preventDefault();
+        }
+    };
+}
+function Input(_a) {
+    var ariaLabel = _a.ariaLabel, autoFocus = _a.autoFocus, className = _a.className, disabled = _a.disabled, inputRef = _a.inputRef, max = _a.max, min = _a.min, name = _a.name, nameForClass = _a.nameForClass, onChange = _a.onChange, onKeyDown = _a.onKeyDown, onKeyUp = _a.onKeyUp, _b = _a.placeholder, placeholder = _b === void 0 ? '--' : _b, required = _a.required, showLeadingZeros = _a.showLeadingZeros, step = _a.step, value = _a.value;
+    useIsomorphicLayoutEffect(function () {
+        if (!inputRef || !inputRef.current) {
+            return;
+        }
+        updateInputWidth(inputRef.current);
+        updateInputWidthOnLoad(inputRef.current);
+        updateInputWidthOnFontLoad(inputRef.current);
+    }, [inputRef, value]);
+    var hasLeadingZero = showLeadingZeros &&
+        value &&
+        Number(value) < 10 &&
+        (value === '0' || !value.toString().startsWith('0'));
+    var maxLength = max ? max.toString().length : null;
+    return (React__default["default"].createElement(React__default["default"].Fragment, null,
+        hasLeadingZero ? React__default["default"].createElement("span", { className: "".concat(className, "__leadingZero") }, "0") : null,
+        React__default["default"].createElement("input", { "aria-label": ariaLabel, autoComplete: "off", autoFocus: autoFocus, className: clsx("".concat(className, "__input"), "".concat(className, "__").concat(nameForClass || name), hasLeadingZero && "".concat(className, "__input--hasLeadingZero")), "data-input": "true", disabled: disabled, inputMode: "numeric", max: max, min: min, name: name, onChange: onChange, onFocus: onFocus, onKeyDown: onKeyDown, onKeyPress: makeOnKeyPress(maxLength), onKeyUp: function (event) {
+                updateInputWidth(event.target);
+                if (onKeyUp) {
+                    onKeyUp(event);
+                }
+            }, placeholder: placeholder, ref: inputRef, required: required, step: step, type: "number", value: value !== null ? value : '' })));
+}
+
+function convert12to24(hour12, amPm) {
+    var hour24 = Number(hour12);
+    if (amPm === 'am' && hour24 === 12) {
+        hour24 = 0;
+    }
+    else if (amPm === 'pm' && hour24 < 12) {
+        hour24 += 12;
+    }
+    return hour24;
+}
+function convert24to12(hour24) {
+    var hour12 = Number(hour24) % 12 || 12;
+    return [hour12, Number(hour24) < 12 ? 'am' : 'pm'];
+}
+
+var formatterCache = new Map();
+function getFormatter(options) {
+    return function formatter(locale, date) {
+        var localeWithDefault = locale || getUserLocale();
+        if (!formatterCache.has(localeWithDefault)) {
+            formatterCache.set(localeWithDefault, new Map());
+        }
+        var formatterCacheLocale = formatterCache.get(localeWithDefault);
+        if (!formatterCacheLocale.has(options)) {
+            formatterCacheLocale.set(options, new Intl.DateTimeFormat(localeWithDefault || undefined, options).format);
+        }
+        return formatterCacheLocale.get(options)(date);
+    };
+}
+var numberFormatterCache = new Map();
+function getNumberFormatter(options) {
+    return function (locale, number) {
+        var localeWithDefault = locale || getUserLocale();
+        if (!numberFormatterCache.has(localeWithDefault)) {
+            numberFormatterCache.set(localeWithDefault, new Map());
+        }
+        var numberFormatterCacheLocale = numberFormatterCache.get(localeWithDefault);
+        if (!numberFormatterCacheLocale.has(options)) {
+            numberFormatterCacheLocale.set(options, new Intl.NumberFormat(localeWithDefault || undefined, options).format);
+        }
+        return numberFormatterCacheLocale.get(options)(number);
+    };
+}
+
+var nines = ['9', '٩'];
+var ninesRegExp = new RegExp("[".concat(nines.join(''), "]"));
+var amPmFormatter = getFormatter({ hour: 'numeric' });
+function getAmPmLabels(locale) {
+    var amString = amPmFormatter(locale, new Date(2017, 0, 1, 9));
+    var pmString = amPmFormatter(locale, new Date(2017, 0, 1, 21));
+    var _a = amString.split(ninesRegExp), am1 = _a[0], am2 = _a[1];
+    var _b = pmString.split(ninesRegExp), pm1 = _b[0], pm2 = _b[1];
+    if (pm2 !== undefined) {
+        // If pm2 is undefined, nine was not found in pmString - this locale is not using 12-hour time
+        if (am1 !== pm1) {
+            return [am1, pm1].map(function (el) { return el.trim(); });
+        }
+        if (am2 !== pm2) {
+            return [am2, pm2].map(function (el) { return el.trim(); });
+        }
+    }
+    // Fallback
+    return ['AM', 'PM'];
+}
+function isValidNumber(num) {
+    return num !== null && num !== false && !Number.isNaN(Number(num));
+}
+function safeMin() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return Math.min.apply(Math, args.filter(isValidNumber));
+}
+function safeMax() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return Math.max.apply(Math, args.filter(isValidNumber));
+}
+
+var __assign$5 = (undefined && undefined.__assign) || function () {
+    __assign$5 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$5.apply(this, arguments);
+};
+var __rest$4 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function Hour12Input(_a) {
+    var amPm = _a.amPm, maxTime = _a.maxTime, minTime = _a.minTime, value = _a.value, otherProps = __rest$4(_a, ["amPm", "maxTime", "minTime", "value"]);
+    var maxHour = safeMin(12, maxTime &&
+        (function () {
+            var _a = convert24to12(getHours(maxTime)), maxHourResult = _a[0], maxAmPm = _a[1];
+            if (maxAmPm !== amPm) {
+                // pm is always after am, so we should ignore validation
+                return null;
+            }
+            return maxHourResult;
+        })());
+    var minHour = safeMax(1, minTime &&
+        (function () {
+            var _a = convert24to12(getHours(minTime)), minHourResult = _a[0], minAmPm = _a[1];
+            if (
+            // pm is always after am, so we should ignore validation
+            minAmPm !== amPm ||
+                // If minHour is 12 am/pm, user should be able to enter 12, 1, ..., 11.
+                minHourResult === 12) {
+                return null;
+            }
+            return minHourResult;
+        })());
+    var value12 = value ? convert24to12(value)[0].toString() : '';
+    return (React__default["default"].createElement(Input, __assign$5({ max: maxHour, min: minHour, name: "hour12", nameForClass: "hour", value: value12 }, otherProps)));
+}
+
+var __assign$4 = (undefined && undefined.__assign) || function () {
+    __assign$4 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$4.apply(this, arguments);
+};
+var __rest$3 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function Hour24Input(_a) {
+    var maxTime = _a.maxTime, minTime = _a.minTime, otherProps = __rest$3(_a, ["maxTime", "minTime"]);
+    var maxHour = safeMin(23, maxTime && getHours(maxTime));
+    var minHour = safeMax(0, minTime && getHours(minTime));
+    return React__default["default"].createElement(Input, __assign$4({ max: maxHour, min: minHour, name: "hour24", nameForClass: "hour" }, otherProps));
+}
+
+var __assign$3 = (undefined && undefined.__assign) || function () {
+    __assign$3 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$3.apply(this, arguments);
+};
+var __rest$2 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function MinuteInput(_a) {
+    var hour = _a.hour, maxTime = _a.maxTime, minTime = _a.minTime, _b = _a.showLeadingZeros, showLeadingZeros = _b === void 0 ? true : _b, otherProps = __rest$2(_a, ["hour", "maxTime", "minTime", "showLeadingZeros"]);
+    function isSameHour(date) {
+        return hour === getHours(date).toString();
+    }
+    var maxMinute = safeMin(59, maxTime && isSameHour(maxTime) && getMinutes(maxTime));
+    var minMinute = safeMax(0, minTime && isSameHour(minTime) && getMinutes(minTime));
+    return (React__default["default"].createElement(Input, __assign$3({ max: maxMinute, min: minMinute, name: "minute", showLeadingZeros: showLeadingZeros }, otherProps)));
+}
+
+var __assign$2 = (undefined && undefined.__assign) || function () {
+    __assign$2 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$2.apply(this, arguments);
+};
+var __rest$1 = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+function SecondInput(_a) {
+    var hour = _a.hour, maxTime = _a.maxTime, minTime = _a.minTime, minute = _a.minute, _b = _a.showLeadingZeros, showLeadingZeros = _b === void 0 ? true : _b, otherProps = __rest$1(_a, ["hour", "maxTime", "minTime", "minute", "showLeadingZeros"]);
+    function isSameMinute(date) {
+        return hour === getHours(date).toString() && minute === getMinutes(date).toString();
+    }
+    var maxSecond = safeMin(59, maxTime && isSameMinute(maxTime) && getSeconds(maxTime));
+    var minSecond = safeMax(0, minTime && isSameMinute(minTime) && getSeconds(minTime));
+    return (React__default["default"].createElement(Input, __assign$2({ max: maxSecond, min: minSecond, name: "second", showLeadingZeros: showLeadingZeros }, otherProps)));
+}
+
+function NativeInput(_a) {
+    var ariaLabel = _a.ariaLabel, disabled = _a.disabled, maxTime = _a.maxTime, minTime = _a.minTime, name = _a.name, onChange = _a.onChange, required = _a.required, value = _a.value, valueType = _a.valueType;
+    var nativeValueParser = (function () {
+        switch (valueType) {
+            case 'hour':
+                return function (receivedValue) { return "".concat(getHours(receivedValue), ":00"); };
+            case 'minute':
+                return getHoursMinutes;
+            case 'second':
+                return getHoursMinutesSeconds;
+            default:
+                throw new Error('Invalid valueType');
+        }
+    })();
+    var step = (function () {
+        switch (valueType) {
+            case 'hour':
+                return 3600;
+            case 'minute':
+                return 60;
+            case 'second':
+                return 1;
+            default:
+                throw new Error('Invalid valueType');
+        }
+    })();
+    function stopPropagation(event) {
+        event.stopPropagation();
+    }
+    return (React__default["default"].createElement("input", { "aria-label": ariaLabel, disabled: disabled, hidden: true, max: maxTime ? nativeValueParser(maxTime) : undefined, min: minTime ? nativeValueParser(minTime) : undefined, name: name, onChange: onChange, onFocus: stopPropagation, required: required, step: step, style: {
+            visibility: 'hidden',
+            position: 'absolute',
+            zIndex: '-999',
+        }, type: "time", value: value ? nativeValueParser(value) : '' }));
+}
+
+function AmPm(_a) {
+    var ariaLabel = _a.ariaLabel, autoFocus = _a.autoFocus, className = _a.className, disabled = _a.disabled, inputRef = _a.inputRef, locale = _a.locale, maxTime = _a.maxTime, minTime = _a.minTime, onChange = _a.onChange, onKeyDown = _a.onKeyDown, required = _a.required, value = _a.value;
+    var amDisabled = minTime ? convert24to12(getHours(minTime))[1] === 'pm' : false;
+    var pmDisabled = maxTime ? convert24to12(getHours(maxTime))[1] === 'am' : false;
+    var name = 'amPm';
+    var _b = getAmPmLabels(locale), amLabel = _b[0], pmLabel = _b[1];
+    return (React__default["default"].createElement("select", { "aria-label": ariaLabel, autoFocus: autoFocus, className: clsx("".concat(className, "__input"), "".concat(className, "__").concat(name)), "data-input": "true", "data-select": "true", disabled: disabled, name: name, onChange: onChange, onKeyDown: onKeyDown, ref: inputRef, required: required, value: value !== null ? value : '' },
+        !value && React__default["default"].createElement("option", { value: "" }, "--"),
+        React__default["default"].createElement("option", { disabled: amDisabled, value: "am" }, amLabel),
+        React__default["default"].createElement("option", { disabled: pmDisabled, value: "pm" }, pmLabel)));
+}
+
+var __assign$1 = (undefined && undefined.__assign) || function () {
+    __assign$1 = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign$1.apply(this, arguments);
+};
+var __spreadArray$1 = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var getFormatterOptionsCache = {};
+var allViews$2 = ['hour', 'minute', 'second'];
+function isInternalInput(element) {
+    return element.dataset.input === 'true';
+}
+function findInput(element, property) {
+    var nextElement = element;
+    do {
+        nextElement = nextElement[property];
+    } while (nextElement && !isInternalInput(nextElement));
+    return nextElement;
+}
+function focus(element) {
+    if (element) {
+        element.focus();
+    }
+}
+function renderCustomInputs(placeholder, elementFunctions, allowMultipleInstances) {
+    var usedFunctions = [];
+    var pattern = new RegExp(Object.keys(elementFunctions)
+        .map(function (el) { return "".concat(el, "+"); })
+        .join('|'), 'g');
+    var matches = placeholder.match(pattern);
+    return placeholder.split(pattern).reduce(function (arr, element, index) {
+        var divider = element && (
+        // eslint-disable-next-line react/no-array-index-key
+        React__default["default"].createElement(Divider, { key: "separator_".concat(index) }, element));
+        var res = __spreadArray$1(__spreadArray$1([], arr, true), [divider], false);
+        var currentMatch = matches && matches[index];
+        if (currentMatch) {
+            var renderFunction = elementFunctions[currentMatch] ||
+                elementFunctions[Object.keys(elementFunctions).find(function (elementFunction) {
+                    return currentMatch.match(elementFunction);
+                })];
+            if (!renderFunction) {
+                return res;
+            }
+            if (!allowMultipleInstances && usedFunctions.includes(renderFunction)) {
+                res.push(currentMatch);
+            }
+            else {
+                res.push(renderFunction(currentMatch, index));
+                usedFunctions.push(renderFunction);
+            }
+        }
+        return res;
+    }, []);
+}
+var formatNumber = getNumberFormatter({ useGrouping: false });
+function TimeInput(_a) {
+    var amPmAriaLabel = _a.amPmAriaLabel, autoFocus = _a.autoFocus, className = _a.className, disabled = _a.disabled, format = _a.format, hourAriaLabel = _a.hourAriaLabel, hourPlaceholder = _a.hourPlaceholder, _b = _a.isClockOpen, isClockOpenProps = _b === void 0 ? null : _b, locale = _a.locale, _c = _a.maxDetail, maxDetail = _c === void 0 ? 'minute' : _c, maxTime = _a.maxTime, minTime = _a.minTime, minuteAriaLabel = _a.minuteAriaLabel, minutePlaceholder = _a.minutePlaceholder, _d = _a.name, name = _d === void 0 ? 'time' : _d, nativeInputAriaLabel = _a.nativeInputAriaLabel, onChangeProps = _a.onChange, onInvalidChange = _a.onInvalidChange, required = _a.required, secondAriaLabel = _a.secondAriaLabel, secondPlaceholder = _a.secondPlaceholder, valueProps = _a.value;
+    var _e = React.useState(null), amPm = _e[0], setAmPm = _e[1];
+    var _f = React.useState(null), hour = _f[0], setHour = _f[1];
+    var _g = React.useState(null), minute = _g[0], setMinute = _g[1];
+    var _h = React.useState(null), second = _h[0], setSecond = _h[1];
+    var _j = React.useState(null), value = _j[0], setValue = _j[1];
+    var amPmInput = React.useRef(null);
+    var hour12Input = React.useRef(null);
+    var hour24Input = React.useRef(null);
+    var minuteInput = React.useRef(null);
+    var secondInput = React.useRef(null);
+    var _k = React.useState(isClockOpenProps), isClockOpen = _k[0], setIsClockOpen = _k[1];
+    var lastPressedKey = React.useRef();
+    React.useEffect(function () {
+        setIsClockOpen(isClockOpenProps);
+    }, [isClockOpenProps]);
+    React.useEffect(function () {
+        var nextValue = valueProps;
+        if (nextValue) {
+            setAmPm(convert24to12(getHours(nextValue))[1]);
+            setHour(getHours(nextValue).toString());
+            setMinute(getMinutes(nextValue).toString());
+            setSecond(getSeconds(nextValue).toString());
+            setValue(nextValue);
+        }
+        else {
+            setAmPm(null);
+            setHour(null);
+            setMinute(null);
+            setSecond(null);
+            setValue(null);
+        }
+    }, [
+        valueProps,
+        minTime,
+        maxTime,
+        maxDetail,
+        // Toggling clock visibility resets values
+        isClockOpen,
+    ]);
+    var valueType = maxDetail;
+    var formatTime = (function () {
+        var level = allViews$2.indexOf(maxDetail);
+        var formatterOptions = getFormatterOptionsCache[level] ||
+            (function () {
+                var options = { hour: 'numeric' };
+                if (level >= 1) {
+                    options.minute = 'numeric';
+                }
+                if (level >= 2) {
+                    options.second = 'numeric';
+                }
+                getFormatterOptionsCache[level] = options;
+                return options;
+            })();
+        return getFormatter(formatterOptions);
+    })();
+    /**
+     * Gets current value in a desired format.
+     */
+    function getProcessedValue(value) {
+        var processFunction = (function () {
+            switch (valueType) {
+                case 'hour':
+                case 'minute':
+                    return getHoursMinutes;
+                case 'second':
+                    return getHoursMinutesSeconds;
+                default:
+                    throw new Error('Invalid valueType');
+            }
+        })();
+        return processFunction(value);
+    }
+    var placeholder = format ||
+        (function () {
+            var hour24 = 21;
+            var hour12 = 9;
+            var minute = 13;
+            var second = 14;
+            var date = new Date(2017, 0, 1, hour24, minute, second);
+            return formatTime(locale, date)
+                .replace(formatNumber(locale, hour12), 'h')
+                .replace(formatNumber(locale, hour24), 'H')
+                .replace(formatNumber(locale, minute), 'mm')
+                .replace(formatNumber(locale, second), 'ss')
+                .replace(new RegExp(getAmPmLabels(locale).join('|')), 'a');
+        })();
+    var divider = (function () {
+        var dividers = placeholder.match(/[^0-9a-z]/i);
+        return dividers ? dividers[0] : null;
+    })();
+    function onClick(event) {
+        if (event.target === event.currentTarget) {
+            // Wrapper was directly clicked
+            var firstInput = event.target.children[1];
+            focus(firstInput);
+        }
+    }
+    function onKeyDown(event) {
+        lastPressedKey.current = event.key;
+        switch (event.key) {
+            case 'ArrowLeft':
+            case 'ArrowRight':
+            case divider: {
+                event.preventDefault();
+                var input = event.target;
+                var property = event.key === 'ArrowLeft' ? 'previousElementSibling' : 'nextElementSibling';
+                var nextInput = findInput(input, property);
+                focus(nextInput);
+                break;
+            }
+        }
+    }
+    function onKeyUp(event) {
+        var key = event.key, input = event.target;
+        var isLastPressedKey = lastPressedKey.current === key;
+        if (!isLastPressedKey) {
+            return;
+        }
+        var isNumberKey = !isNaN(Number(key));
+        if (!isNumberKey) {
+            return;
+        }
+        var max = input.getAttribute('max');
+        if (!max) {
+            return;
+        }
+        var value = input.value;
+        /**
+         * Given 1, the smallest possible number the user could type by adding another digit is 10.
+         * 10 would be a valid value given max = 12, so we won't jump to the next input.
+         * However, given 2, smallers possible number would be 20, and thus keeping the focus in
+         * this field doesn't make sense.
+         */
+        if (Number(value) * 10 > Number(max) || value.length >= max.length) {
+            var property = 'nextElementSibling';
+            var nextInput = findInput(input, property);
+            focus(nextInput);
+        }
+    }
+    /**
+     * Called after internal onChange. Checks input validity. If all fields are valid,
+     * calls props.onChange.
+     */
+    function onChangeExternal() {
+        if (!onChangeProps) {
+            return;
+        }
+        function filterBoolean(value) {
+            return Boolean(value);
+        }
+        var formElements = [
+            amPmInput.current,
+            hour12Input.current,
+            hour24Input.current,
+            minuteInput.current,
+            secondInput.current,
+        ].filter(filterBoolean);
+        var formElementsWithoutSelect = formElements.slice(1);
+        var values = {};
+        formElements.forEach(function (formElement) {
+            values[formElement.name] =
+                formElement.type === 'number'
+                    ? 'valueAsNumber' in formElement
+                        ? formElement.valueAsNumber
+                        : Number(formElement.value)
+                    : formElement.value;
+        });
+        var isEveryValueEmpty = formElementsWithoutSelect.every(function (formElement) { return !formElement.value; });
+        if (isEveryValueEmpty) {
+            onChangeProps(null, false);
+            return;
+        }
+        var isEveryValueFilled = formElements.every(function (formElement) { return formElement.value; });
+        var isEveryValueValid = formElements.every(function (formElement) { return formElement.validity.valid; });
+        if (isEveryValueFilled && isEveryValueValid) {
+            var hour_1 = Number(values.hour24 ||
+                (values.hour12 && values.amPm && convert12to24(values.hour12, values.amPm)) ||
+                0);
+            var minute_1 = Number(values.minute || 0);
+            var second_1 = Number(values.second || 0);
+            var padStart = function (num) { return "0".concat(num).slice(-2); };
+            var proposedValue = "".concat(padStart(hour_1), ":").concat(padStart(minute_1), ":").concat(padStart(second_1));
+            var processedValue = getProcessedValue(proposedValue);
+            onChangeProps(processedValue, false);
+            return;
+        }
+        if (!onInvalidChange) {
+            return;
+        }
+        onInvalidChange();
+    }
+    /**
+     * Called when non-native date input is changed.
+     */
+    function onChange(event) {
+        var _a = event.target, name = _a.name, value = _a.value;
+        switch (name) {
+            case 'amPm':
+                setAmPm(value);
+                break;
+            case 'hour12':
+                setHour(value ? convert12to24(value, amPm || 'am').toString() : '');
+                break;
+            case 'hour24':
+                setHour(value);
+                break;
+            case 'minute':
+                setMinute(value);
+                break;
+            case 'second':
+                setSecond(value);
+                break;
+        }
+        onChangeExternal();
+    }
+    /**
+     * Called when native date input is changed.
+     */
+    function onChangeNative(event) {
+        var value = event.target.value;
+        if (!onChangeProps) {
+            return;
+        }
+        var processedValue = value || null;
+        onChangeProps(processedValue, false);
+    }
+    var commonInputProps = {
+        className: className,
+        disabled: disabled,
+        maxTime: maxTime,
+        minTime: minTime,
+        onChange: onChange,
+        onKeyDown: onKeyDown,
+        onKeyUp: onKeyUp,
+        // This is only for showing validity when editing
+        required: Boolean(required || isClockOpen),
+    };
+    function renderHour12(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : false;
+        return (React__default["default"].createElement(Hour12Input, __assign$1({ key: "hour12" }, commonInputProps, { amPm: amPm, ariaLabel: hourAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, inputRef: hour12Input, placeholder: hourPlaceholder, showLeadingZeros: showLeadingZeros, value: hour })));
+    }
+    function renderHour24(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : false;
+        return (React__default["default"].createElement(Hour24Input, __assign$1({ key: "hour24" }, commonInputProps, { ariaLabel: hourAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, inputRef: hour24Input, placeholder: hourPlaceholder, showLeadingZeros: showLeadingZeros, value: hour })));
+    }
+    function renderHour(currentMatch, index) {
+        if (/h/.test(currentMatch)) {
+            return renderHour12(currentMatch, index);
+        }
+        return renderHour24(currentMatch, index);
+    }
+    function renderMinute(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : false;
+        return (React__default["default"].createElement(MinuteInput, __assign$1({ key: "minute" }, commonInputProps, { ariaLabel: minuteAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, hour: hour, inputRef: minuteInput, placeholder: minutePlaceholder, showLeadingZeros: showLeadingZeros, value: minute })));
+    }
+    function renderSecond(currentMatch, index) {
+        if (currentMatch && currentMatch.length > 2) {
+            throw new Error("Unsupported token: ".concat(currentMatch));
+        }
+        var showLeadingZeros = currentMatch ? currentMatch.length === 2 : true;
+        return (React__default["default"].createElement(SecondInput, __assign$1({ key: "second" }, commonInputProps, { ariaLabel: secondAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, hour: hour, inputRef: secondInput, minute: minute, placeholder: secondPlaceholder, showLeadingZeros: showLeadingZeros, value: second })));
+    }
+    function renderAmPm(currentMatch, index) {
+        return (React__default["default"].createElement(AmPm, __assign$1({ key: "ampm" }, commonInputProps, { ariaLabel: amPmAriaLabel, 
+            // eslint-disable-next-line jsx-a11y/no-autofocus
+            autoFocus: index === 0 && autoFocus, inputRef: amPmInput, locale: locale, onChange: onChange, value: amPm })));
+    }
+    function renderCustomInputsInternal() {
+        var elementFunctions = {
+            h: renderHour,
+            H: renderHour,
+            m: renderMinute,
+            s: renderSecond,
+            a: renderAmPm,
+        };
+        var allowMultipleInstances = typeof format !== 'undefined';
+        return renderCustomInputs(placeholder, elementFunctions, allowMultipleInstances);
+    }
+    function renderNativeInput() {
+        return (React__default["default"].createElement(NativeInput, { key: "time", ariaLabel: nativeInputAriaLabel, disabled: disabled, maxTime: maxTime, minTime: minTime, name: name, onChange: onChangeNative, required: required, value: value, valueType: valueType }));
+    }
+    return (
+    // eslint-disable-next-line jsx-a11y/click-events-have-key-events, jsx-a11y/no-static-element-interactions
+    React__default["default"].createElement("div", { className: className, onClick: onClick },
+        renderNativeInput(),
+        renderCustomInputsInternal()));
+}
+
+var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var allViews$1 = ['hour', 'minute', 'second'];
+var allValueTypes = __spreadArray([], allViews$1, true);
+var hourOptionalSecondsRegExp = /^(([0-1])?[0-9]|2[0-3]):[0-5][0-9](:([0-5][0-9]))?$/;
+var isTime = function isTime(props, propName, componentName) {
+    var _a = props, _b = propName, time = _a[_b];
+    if (time) {
+        if (typeof time !== 'string' || !hourOptionalSecondsRegExp.test(time)) {
+            return new Error("Invalid prop `".concat(propName, "` of type `").concat(typeof time, "` supplied to `").concat(componentName, "`, expected time in HH:mm(:ss) format."));
+        }
+    }
+    // Everything is fine
+    return null;
+};
+index.propTypes.exports.oneOf(allValueTypes);
+index.propTypes.exports.oneOfType([
+    index.propTypes.exports.func,
+    index.propTypes.exports.exact({
+        current: index.propTypes.exports.any,
+    }),
+]);
+var rangeOf = function (type) {
+    return index.propTypes.exports.arrayOf(type);
+};
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var isBrowser = typeof document !== 'undefined';
+var baseClassName = 'react-time-picker';
+var outsideActionEvents = ['mousedown', 'focusin', 'touchstart'];
+var allViews = ['hour', 'minute', 'second'];
+var iconProps = {
+    xmlns: 'http://www.w3.org/2000/svg',
+    width: 19,
+    height: 19,
+    viewBox: '0 0 19 19',
+    stroke: 'black',
+    strokeWidth: 2,
+};
+var ClockIcon = (React__default["default"].createElement("svg", __assign({}, iconProps, { className: "".concat(baseClassName, "__clock-button__icon ").concat(baseClassName, "__button__icon"), fill: "none" }),
+    React__default["default"].createElement("circle", { cx: "9.5", cy: "9.5", r: "7.5" }),
+    React__default["default"].createElement("path", { d: "M9.5 4.5 v5 h4" })));
+var ClearIcon = (React__default["default"].createElement("svg", __assign({}, iconProps, { className: "".concat(baseClassName, "__clear-button__icon ").concat(baseClassName, "__button__icon") }),
+    React__default["default"].createElement("line", { x1: "4", x2: "15", y1: "4", y2: "15" }),
+    React__default["default"].createElement("line", { x1: "15", x2: "4", y1: "4", y2: "15" })));
+var TimePicker = function TimePicker(props) {
+    var amPmAriaLabel = props.amPmAriaLabel, autoFocus = props.autoFocus, className = props.className, clearAriaLabel = props.clearAriaLabel, _a = props.clearIcon, clearIcon = _a === void 0 ? ClearIcon : _a, clockAriaLabel = props.clockAriaLabel, _b = props.clockIcon, clockIcon = _b === void 0 ? ClockIcon : _b, _c = props.closeClock, shouldCloseClockOnSelect = _c === void 0 ? true : _c, dataTestid = props["data-testid"], hourAriaLabel = props.hourAriaLabel, hourPlaceholder = props.hourPlaceholder, disableClock = props.disableClock, disabled = props.disabled, format = props.format, id = props.id, _d = props.isOpen, isOpenProps = _d === void 0 ? null : _d, locale = props.locale, maxTime = props.maxTime, _e = props.maxDetail, maxDetail = _e === void 0 ? 'minute' : _e, minTime = props.minTime, minuteAriaLabel = props.minuteAriaLabel, minutePlaceholder = props.minutePlaceholder, _f = props.name, name = _f === void 0 ? 'time' : _f, nativeInputAriaLabel = props.nativeInputAriaLabel, onClockClose = props.onClockClose, onClockOpen = props.onClockOpen, onChangeProps = props.onChange, onFocusProps = props.onFocus, onInvalidChange = props.onInvalidChange, _g = props.openClockOnFocus, openClockOnFocus = _g === void 0 ? true : _g, required = props.required, value = props.value, secondAriaLabel = props.secondAriaLabel, secondPlaceholder = props.secondPlaceholder, shouldCloseClock = props.shouldCloseClock, shouldOpenClock = props.shouldOpenClock, otherProps = __rest(props, ["amPmAriaLabel", "autoFocus", "className", "clearAriaLabel", "clearIcon", "clockAriaLabel", "clockIcon", "closeClock", 'data-testid', "hourAriaLabel", "hourPlaceholder", "disableClock", "disabled", "format", "id", "isOpen", "locale", "maxTime", "maxDetail", "minTime", "minuteAriaLabel", "minutePlaceholder", "name", "nativeInputAriaLabel", "onClockClose", "onClockOpen", "onChange", "onFocus", "onInvalidChange", "openClockOnFocus", "required", "value", "secondAriaLabel", "secondPlaceholder", "shouldCloseClock", "shouldOpenClock"]);
+    var _h = React.useState(isOpenProps), isOpen = _h[0], setIsOpen = _h[1];
+    var wrapper = React.useRef(null);
+    var clockWrapper = React.useRef(null);
+    React.useEffect(function () {
+        setIsOpen(isOpenProps);
+    }, [isOpenProps]);
+    function openClock(_a) {
+        var reason = _a.reason;
+        if (shouldOpenClock) {
+            if (!shouldOpenClock({ reason: reason })) {
+                return;
+            }
+        }
+        setIsOpen(true);
+        if (onClockOpen) {
+            onClockOpen();
+        }
+    }
+    var closeClock = React.useCallback(function (_a) {
+        var reason = _a.reason;
+        if (shouldCloseClock) {
+            if (!shouldCloseClock({ reason: reason })) {
+                return;
+            }
+        }
+        setIsOpen(false);
+        if (onClockClose) {
+            onClockClose();
+        }
+    }, [onClockClose, shouldCloseClock]);
+    function toggleClock() {
+        if (isOpen) {
+            closeClock({ reason: 'buttonClick' });
+        }
+        else {
+            openClock({ reason: 'buttonClick' });
+        }
+    }
+    function onChange(value, shouldCloseClock) {
+        if (shouldCloseClock === void 0) { shouldCloseClock = shouldCloseClockOnSelect; }
+        if (shouldCloseClock) {
+            closeClock({ reason: 'select' });
+        }
+        if (onChangeProps) {
+            onChangeProps(value);
+        }
+    }
+    function onFocus(event) {
+        if (onFocusProps) {
+            onFocusProps(event);
+        }
+        if (
+        // Internet Explorer still fires onFocus on disabled elements
+        disabled ||
+            isOpen ||
+            !openClockOnFocus ||
+            event.target.dataset.select === 'true') {
+            return;
+        }
+        openClock({ reason: 'focus' });
+    }
+    var onKeyDown = React.useCallback(function (event) {
+        if (event.key === 'Escape') {
+            closeClock({ reason: 'escape' });
+        }
+    }, [closeClock]);
+    function clear() {
+        onChange(null);
+    }
+    function stopPropagation(event) {
+        event.stopPropagation();
+    }
+    var onOutsideAction = React.useCallback(function (event) {
+        var wrapperEl = wrapper.current;
+        var clockWrapperEl = clockWrapper.current;
+        // Try event.composedPath first to handle clicks inside a Shadow DOM.
+        var target = ('composedPath' in event ? event.composedPath()[0] : event.target);
+        if (target &&
+            wrapperEl &&
+            !wrapperEl.contains(target) &&
+            (!clockWrapperEl || !clockWrapperEl.contains(target))) {
+            closeClock({ reason: 'outsideAction' });
+        }
+    }, [clockWrapper, closeClock, wrapper]);
+    var handleOutsideActionListeners = React.useCallback(function (shouldListen) {
+        if (shouldListen === void 0) { shouldListen = isOpen; }
+        outsideActionEvents.forEach(function (event) {
+            if (shouldListen) {
+                document.addEventListener(event, onOutsideAction);
+            }
+            else {
+                document.removeEventListener(event, onOutsideAction);
+            }
+        });
+        if (shouldListen) {
+            document.addEventListener('keydown', onKeyDown);
+        }
+        else {
+            document.removeEventListener('keydown', onKeyDown);
+        }
+    }, [isOpen, onOutsideAction, onKeyDown]);
+    React.useEffect(function () {
+        handleOutsideActionListeners();
+        return function () {
+            handleOutsideActionListeners(false);
+        };
+    }, [handleOutsideActionListeners]);
+    function renderInputs() {
+        var valueFrom = (Array.isArray(value) ? value : [value])[0];
+        var ariaLabelProps = {
+            amPmAriaLabel: amPmAriaLabel,
+            hourAriaLabel: hourAriaLabel,
+            minuteAriaLabel: minuteAriaLabel,
+            nativeInputAriaLabel: nativeInputAriaLabel,
+            secondAriaLabel: secondAriaLabel,
+        };
+        var placeholderProps = {
+            hourPlaceholder: hourPlaceholder,
+            minutePlaceholder: minutePlaceholder,
+            secondPlaceholder: secondPlaceholder,
+        };
+        return (React__default["default"].createElement("div", { className: "".concat(baseClassName, "__wrapper") },
+            React__default["default"].createElement(TimeInput, __assign({}, ariaLabelProps, placeholderProps, { 
+                // eslint-disable-next-line jsx-a11y/no-autofocus
+                autoFocus: autoFocus, className: "".concat(baseClassName, "__inputGroup"), disabled: disabled, format: format, isClockOpen: isOpen, locale: locale, maxDetail: maxDetail, maxTime: maxTime, minTime: minTime, name: name, onChange: onChange, onInvalidChange: onInvalidChange, required: required, value: valueFrom })),
+            clearIcon !== null && (React__default["default"].createElement("button", { "aria-label": clearAriaLabel, className: "".concat(baseClassName, "__clear-button ").concat(baseClassName, "__button"), disabled: disabled, onClick: clear, onFocus: stopPropagation, type: "button" }, typeof clearIcon === 'function' ? React__default["default"].createElement(clearIcon) : clearIcon)),
+            clockIcon !== null && !disableClock && (React__default["default"].createElement("button", { "aria-label": clockAriaLabel, className: "".concat(baseClassName, "__clock-button ").concat(baseClassName, "__button"), disabled: disabled, onClick: toggleClock, onFocus: stopPropagation, type: "button" }, typeof clockIcon === 'function' ? React__default["default"].createElement(clockIcon) : clockIcon))));
+    }
+    function renderClock() {
+        if (isOpen === null || disableClock) {
+            return null;
+        }
+        var clockClassName = props.clockClassName; props.className; // Unused, here to exclude it from clockProps
+        props.onChange; // Unused, here to exclude it from clockProps
+        var portalContainer = props.portalContainer, value = props.value, clockProps = __rest(props, ["clockClassName", "className", "onChange", "portalContainer", "value"]);
+        var className = "".concat(baseClassName, "__clock");
+        var classNames = clsx(className, "".concat(className, "--").concat(isOpen ? 'open' : 'closed'));
+        var valueFrom = (Array.isArray(value) ? value : [value])[0];
+        var clock = React__default["default"].createElement(Clock, __assign({ className: clockClassName, value: valueFrom }, clockProps));
+        return portalContainer ? (ReactDOM.createPortal(React__default["default"].createElement("div", { ref: clockWrapper, className: classNames }, clock), portalContainer)) : (React__default["default"].createElement(Fit, null,
+            React__default["default"].createElement("div", { ref: function (ref) {
+                    if (ref && !isOpen) {
+                        ref.removeAttribute('style');
+                    }
+                }, className: classNames }, clock)));
+    }
+    var eventProps = React.useMemo(function () { return makeEventProps(otherProps); }, [otherProps]);
+    return (React__default["default"].createElement("div", __assign({ className: clsx(baseClassName, "".concat(baseClassName, "--").concat(isOpen ? 'open' : 'closed'), "".concat(baseClassName, "--").concat(disabled ? 'disabled' : 'enabled'), className), "data-testid": dataTestid, id: id }, eventProps, { onFocus: onFocus, ref: wrapper }),
+        renderInputs(),
+        renderClock()));
+};
+var isValue = index.propTypes.exports.oneOfType([isTime, index.propTypes.exports.instanceOf(Date)]);
+var isValueOrValueArray = index.propTypes.exports.oneOfType([isValue, rangeOf(isValue)]);
+TimePicker.propTypes = {
+    amPmAriaLabel: index.propTypes.exports.string,
+    autoFocus: index.propTypes.exports.bool,
+    className: index.propTypes.exports.oneOfType([index.propTypes.exports.string, index.propTypes.exports.arrayOf(index.propTypes.exports.string)]),
+    clearAriaLabel: index.propTypes.exports.string,
+    clearIcon: index.propTypes.exports.oneOfType([index.propTypes.exports.node, index.propTypes.exports.func]),
+    clockAriaLabel: index.propTypes.exports.string,
+    clockClassName: index.propTypes.exports.oneOfType([index.propTypes.exports.string, index.propTypes.exports.arrayOf(index.propTypes.exports.string)]),
+    clockIcon: index.propTypes.exports.oneOfType([index.propTypes.exports.node, index.propTypes.exports.func]),
+    closeClock: index.propTypes.exports.bool,
+    'data-testid': index.propTypes.exports.string,
+    disableClock: index.propTypes.exports.bool,
+    disabled: index.propTypes.exports.bool,
+    format: index.propTypes.exports.string,
+    hourAriaLabel: index.propTypes.exports.string,
+    hourPlaceholder: index.propTypes.exports.string,
+    id: index.propTypes.exports.string,
+    isOpen: index.propTypes.exports.bool,
+    locale: index.propTypes.exports.string,
+    maxDetail: index.propTypes.exports.oneOf(allViews),
+    maxTime: isTime,
+    minTime: isTime,
+    minuteAriaLabel: index.propTypes.exports.string,
+    minutePlaceholder: index.propTypes.exports.string,
+    name: index.propTypes.exports.string,
+    nativeInputAriaLabel: index.propTypes.exports.string,
+    onChange: index.propTypes.exports.func,
+    onClockClose: index.propTypes.exports.func,
+    onClockOpen: index.propTypes.exports.func,
+    onFocus: index.propTypes.exports.func,
+    openClockOnFocus: index.propTypes.exports.bool,
+    required: index.propTypes.exports.bool,
+    secondAriaLabel: index.propTypes.exports.string,
+    secondPlaceholder: index.propTypes.exports.string,
+    value: isValueOrValueArray,
+};
+if (isBrowser) {
+    TimePicker.propTypes.portalContainer = index.propTypes.exports.instanceOf(HTMLElement);
+}
+
+var HoverIcon = function HoverIcon(_ref) {
+  var _ref$time = _ref.time,
+    time = _ref$time === void 0 ? false : _ref$time;
+  var _useState = React.useState(false),
+    _useState2 = slicedToArray._slicedToArray(_useState, 2),
+    hovered = _useState2[0],
+    setHovered = _useState2[1];
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    onMouseLeave: function onMouseLeave() {
+      return setHovered(false);
+    },
+    onMouseOver: function onMouseOver() {
+      return setHovered(true);
+    }
+  }, hovered && time ? /*#__PURE__*/React__default["default"].createElement(neetoIcons.Close, {
+    size: 16
+  }) : /*#__PURE__*/React__default["default"].createElement(neetoIcons.Clock, {
+    size: 16
+  }));
+};
+
+// A wrapper hook around useState, that updates a ref as well, useful when dealing directly with dom event listeners.
+var useRefState = function useRefState(val) {
+  // eslint-disable-next-line react/hook-use-state
+  var _useState = React.useState(val),
+    _useState2 = slicedToArray._slicedToArray(_useState, 2),
+    value = _useState2[0],
+    _setValue = _useState2[1];
+  var valueRef = React.useRef(value);
+  var setValue = function setValue(val) {
+    valueRef.current = val;
+    _setValue(val);
+  };
+  return [value, valueRef, setValue];
+};
+
+var FORMAT = "HH:mm";
+var getFormattedTime = function getFormattedTime(value) {
+  if (index$1.dayjs.isDayjs(value)) {
+    return value.toDate();
+  } else if (value instanceof Date || index$1.dayjs(value, FORMAT).isValid()) {
+    return value;
+  }
+  return null;
+};
+var getFormattedRange = function getFormattedRange(value) {
+  if (!Array.isArray(value)) return null;
+  return value.map(function (item) {
+    return getFormattedTime(item);
+  });
+};
+var toDayJs = function toDayJs(value) {
+  if (Array.isArray(value)) return value.map(function (item) {
+    return index$1.dayjs(item, FORMAT);
+  });
+  return index$1.dayjs(value, FORMAT);
+};
+var isValidTime = function isValidTime(minTime, maxTime, value) {
+  if (neetoCist.isPresent(minTime) && toDayJs(value).isBefore(toDayJs(minTime))) {
+    return false;
+  }
+  return !(neetoCist.isPresent(maxTime) && toDayJs(value).isAfter(toDayJs(maxTime)));
+};
+var isValidRange = function isValidRange(minTime, maxTime, value) {
+  return value.every(function (item) {
+    return isValid(minTime, maxTime, item);
+  });
+};
+var isValid = function isValid(minTime, maxTime, value) {
+  return (Array.isArray(value) ? isValidRange : isValidTime)(minTime, maxTime, value);
+};
+var getValidTime = function getValidTime(minTime, maxTime, value) {
+  if (neetoCist.isPresent(minTime) && toDayJs(value).isBefore(toDayJs(minTime))) {
+    return minTime;
+  }
+  if (neetoCist.isPresent(maxTime) && toDayJs(value).isAfter(toDayJs(maxTime))) {
+    return maxTime;
+  }
+  return value;
+};
+var getValidRange = function getValidRange(minTime, maxTime, value) {
+  return value.map(function (item) {
+    return getValidTime(minTime, maxTime, item);
+  });
+};
+var getValid = function getValid(minTime, maxTime, value) {
+  return (Array.isArray(value) ? getValidRange : getValidTime)(minTime, maxTime, value);
+};
+
+var _excluded = ["type", "className", "label", "labelProps", "size", "nakedInput", "required", "value", "defaultValue", "onChange", "error", "onBlur", "minTime", "maxTime"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { defineProperty._defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+index$1.dayjs.extend(customParseFormat);
+var INPUT_SIZES = {
+  small: "small",
+  medium: "medium",
+  large: "large"
+};
+var timeComponents = {
+  range: TimeRangePicker,
+  time: TimePicker
+};
+var TimePickerInput = /*#__PURE__*/React.forwardRef(function (_ref, ref) {
+  var _ref$type = _ref.type,
+    type = _ref$type === void 0 ? "time" : _ref$type,
+    _ref$className = _ref.className,
+    className = _ref$className === void 0 ? "" : _ref$className,
+    label = _ref.label,
+    labelProps = _ref.labelProps,
+    _ref$size = _ref.size,
+    size = _ref$size === void 0 ? INPUT_SIZES.medium : _ref$size,
+    _ref$nakedInput = _ref.nakedInput,
+    nakedInput = _ref$nakedInput === void 0 ? false : _ref$nakedInput,
+    _ref$required = _ref.required,
+    required = _ref$required === void 0 ? false : _ref$required,
+    inputValue = _ref.value,
+    defaultValue = _ref.defaultValue,
+    _ref$onChange = _ref.onChange,
+    onChange = _ref$onChange === void 0 ? index$1.noop : _ref$onChange,
+    _ref$error = _ref.error,
+    error = _ref$error === void 0 ? "" : _ref$error,
+    _ref$onBlur = _ref.onBlur,
+    onBlur = _ref$onBlur === void 0 ? index$1.noop : _ref$onBlur,
+    minTime = _ref.minTime,
+    maxTime = _ref.maxTime,
+    otherProps = objectWithoutProperties._objectWithoutProperties(_ref, _excluded);
+  var _useRefState = useRefState(null),
+    _useRefState2 = slicedToArray._slicedToArray(_useRefState, 3),
+    value = _useRefState2[0],
+    valueRef = _useRefState2[1],
+    setValue = _useRefState2[2];
+  var componentRef = React.useRef(null);
+  var id = useId.useId(otherProps.id);
+  var errorId = "error_".concat(id);
+  React.useEffect(function () {
+    if (neetoCist.isNotPresent(inputValue) && neetoCist.isNotPresent(defaultValue)) return;
+    setValue((type === "range" ? getFormattedRange : getFormattedTime)(inputValue || defaultValue));
+  }, [type, inputValue]);
+  var handleChange = function handleChange(newValue) {
+    setValue(newValue);
+    if (isValid(minTime, maxTime, newValue)) {
+      onChange(toDayJs(newValue), newValue);
+    }
+  };
+  var onBlurHandle = function onBlurHandle() {
+    if (isValid(minTime, maxTime, value)) {
+      onBlur(toDayJs(value), value);
+    } else {
+      var validValue = getValid(minTime, maxTime, value);
+      setValue(validValue);
+      onChange(toDayJs(validValue), validValue);
+      onBlur(toDayJs(validValue), validValue);
+    }
+    return true;
+  };
+  var onAmPmChange = function onAmPmChange() {
+    var value = valueRef.current;
+    if (!isValid(minTime, maxTime, value)) {
+      var validValue = getValid(minTime, maxTime, value);
+      setValue(validValue);
+      onChange(toDayJs(validValue), validValue);
+    }
+  };
+
+  // If you just make amPm select change, onBlurHandle is not triggering. A work around
+  React.useEffect(function () {
+    var _document$getElementB;
+    var amPmChange = function amPmChange() {
+      return setTimeout(onAmPmChange);
+    };
+    var selectElements = (_document$getElementB = document.getElementById(id)) === null || _document$getElementB === void 0 ? void 0 : _document$getElementB.querySelectorAll("[name='amPm']");
+    selectElements === null || selectElements === void 0 || selectElements.forEach(function (element) {
+      return element.addEventListener("change", amPmChange);
+    });
+    return function () {
+      selectElements === null || selectElements === void 0 || selectElements.forEach(function (element) {
+        return element.removeEventListener("change", amPmChange);
+      });
+    };
+  }, [value]);
+  var handleKeyDown = function handleKeyDown(_ref2) {
+    var code = _ref2.code;
+    if (code !== "Enter") return;
+    onBlurHandle();
+  };
+  var Component = timeComponents[type];
+  return /*#__PURE__*/React__default["default"].createElement("div", {
+    ref: ref,
+    className: "neeto-ui-input__wrapper"
+  }, label && /*#__PURE__*/React__default["default"].createElement(Label, _objectSpread({
+    required: required
+  }, labelProps), label), /*#__PURE__*/React__default["default"].createElement(Component, _extends._extends({
+    id: id,
+    value: value,
+    disableClock: true,
+    clearIcon: /*#__PURE__*/React__default["default"].createElement(HoverIcon, {
+      time: !!value
+    }),
+    format: "hh:mm a",
+    hourPlaceholder: "HH",
+    minutePlaceholder: "mm",
+    ref: componentRef,
+    secondAriaLabel: "ss",
+    shouldCloseClock: onBlurHandle,
+    className: index$2.classnames("neeto-ui-time-picker", [className], {
+      "neeto-ui-time-picker--small": size === "small",
+      "neeto-ui-time-picker--medium": size === "medium",
+      "neeto-ui-time-picker--large": size === "large",
+      "neeto-ui-time-picker--disabled": otherProps.disabled,
+      "neeto-ui-time-picker--naked": nakedInput,
+      "neeto-ui-time-picker--error": !!error
+    }),
+    onChange: handleChange,
+    onKeyDown: handleKeyDown
+  }, otherProps)), !!error && typeof error === "string" && /*#__PURE__*/React__default["default"].createElement("p", {
+    className: "neeto-ui-input__error",
+    "data-cy": "".concat(index$1.hyphenize(label), "-input-error"),
+    id: errorId
+  }, error));
+});
+TimePickerInput.displayName = "TimePicker";
+
+exports.TimePickerInput = TimePickerInput;
+exports.customParseFormat = customParseFormat;
+//# sourceMappingURL=index-a780bb4a.js.map