Latest updates from IceHrmPro

web/node_modules/rc-picker/es/PanelContext.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { OnSelect } from './interface';
+export declare type ContextOperationRefProps = {
+    onKeyDown?: (e: React.KeyboardEvent<HTMLElement>) => boolean;
+    onClose?: () => void;
+};
+export interface PanelContextProps {
+    operationRef?: React.MutableRefObject<ContextOperationRefProps | null>;
+    /** Only work with time panel */
+    hideHeader?: boolean;
+    panelRef?: React.Ref<HTMLDivElement>;
+    hidePrevBtn?: boolean;
+    hideNextBtn?: boolean;
+    onDateMouseEnter?: (date: any) => void;
+    onDateMouseLeave?: (date: any) => void;
+    onSelect?: OnSelect<any>;
+    hideRanges?: boolean;
+    open?: boolean;
+    /** Only used for TimePicker and this is a deprecated prop */
+    defaultOpenValue?: any;
+}
+declare const PanelContext: React.Context<PanelContextProps>;
+export default PanelContext;

web/node_modules/rc-picker/es/PanelContext.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+var PanelContext = React.createContext({});
+export default PanelContext;

web/node_modules/rc-picker/es/Picker.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Removed:
+ *  - getCalendarContainer: use `getPopupContainer` instead
+ *  - onOk
+ *
+ * New Feature:
+ *  - picker
+ *  - allowEmpty
+ *  - selectable
+ *
+ * Tips: Should add faq about `datetime` mode with `defaultValue`
+ */
+import * as React from 'react';
+import { AlignType } from 'rc-trigger/lib/interface';
+import { PickerPanelBaseProps, PickerPanelDateProps, PickerPanelTimeProps } from './PickerPanel';
+export interface PickerRefConfig {
+    focus: () => void;
+    blur: () => void;
+}
+export interface PickerSharedProps<DateType> extends React.AriaAttributes {
+    dropdownClassName?: string;
+    dropdownAlign?: AlignType;
+    popupStyle?: React.CSSProperties;
+    transitionName?: string;
+    placeholder?: string;
+    allowClear?: boolean;
+    autoFocus?: boolean;
+    disabled?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    /** Make input readOnly to avoid popup keyboard in mobile */
+    inputReadOnly?: boolean;
+    format?: string | string[];
+    suffixIcon?: React.ReactNode;
+    clearIcon?: React.ReactNode;
+    prevIcon?: React.ReactNode;
+    nextIcon?: React.ReactNode;
+    superPrevIcon?: React.ReactNode;
+    superNextIcon?: React.ReactNode;
+    getPopupContainer?: (node: HTMLElement) => HTMLElement;
+    onChange?: (value: DateType | null, dateString: string) => void;
+    onOpenChange?: (open: boolean) => void;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+    onMouseDown?: React.MouseEventHandler<HTMLDivElement>;
+    onMouseUp?: React.MouseEventHandler<HTMLDivElement>;
+    onMouseEnter?: React.MouseEventHandler<HTMLDivElement>;
+    onMouseLeave?: React.MouseEventHandler<HTMLDivElement>;
+    onClick?: React.MouseEventHandler<HTMLDivElement>;
+    onContextMenu?: React.MouseEventHandler<HTMLDivElement>;
+    /** @private Internal usage, do not use in production mode!!! */
+    pickerRef?: React.MutableRefObject<PickerRefConfig>;
+    role?: string;
+    name?: string;
+    autoComplete?: string;
+    direction?: 'ltr' | 'rtl';
+}
+declare type OmitPanelProps<Props> = Omit<Props, 'onChange' | 'hideHeader' | 'pickerValue' | 'onPickerValueChange'>;
+export interface PickerBaseProps<DateType> extends PickerSharedProps<DateType>, OmitPanelProps<PickerPanelBaseProps<DateType>> {
+}
+export interface PickerDateProps<DateType> extends PickerSharedProps<DateType>, OmitPanelProps<PickerPanelDateProps<DateType>> {
+}
+export interface PickerTimeProps<DateType> extends PickerSharedProps<DateType>, Omit<OmitPanelProps<PickerPanelTimeProps<DateType>>, 'format'> {
+    picker: 'time';
+    /**
+     * @deprecated Please use `defaultValue` directly instead
+     * since `defaultOpenValue` will confuse user of current value status
+     */
+    defaultOpenValue?: DateType;
+}
+export declare type PickerProps<DateType> = PickerBaseProps<DateType> | PickerDateProps<DateType> | PickerTimeProps<DateType>;
+declare class Picker<DateType> extends React.Component<PickerProps<DateType>> {
+    pickerRef: React.RefObject<PickerRefConfig>;
+    focus: () => void;
+    blur: () => void;
+    render(): JSX.Element;
+}
+export default Picker;

web/node_modules/rc-picker/es/Picker.js

@@ -0,0 +1,459 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+/**
+ * Removed:
+ *  - getCalendarContainer: use `getPopupContainer` instead
+ *  - onOk
+ *
+ * New Feature:
+ *  - picker
+ *  - allowEmpty
+ *  - selectable
+ *
+ * Tips: Should add faq about `datetime` mode with `defaultValue`
+ */
+import * as React from 'react';
+import classNames from 'classnames';
+import warning from "rc-util/es/warning";
+import useMergedState from "rc-util/es/hooks/useMergedState";
+import PickerPanel from './PickerPanel';
+import PickerTrigger from './PickerTrigger';
+import { isEqual } from './utils/dateUtil';
+import getDataOrAriaProps, { toArray } from './utils/miscUtil';
+import PanelContext from './PanelContext';
+import { getDefaultFormat, getInputSize, elementsContains } from './utils/uiUtil';
+import usePickerInput from './hooks/usePickerInput';
+import useTextValueMapping from './hooks/useTextValueMapping';
+import useValueTexts from './hooks/useValueTexts';
+
+function InnerPicker(props) {
+  var _classNames2;
+
+  var _props$prefixCls = props.prefixCls,
+      prefixCls = _props$prefixCls === void 0 ? 'rc-picker' : _props$prefixCls,
+      style = props.style,
+      className = props.className,
+      dropdownClassName = props.dropdownClassName,
+      dropdownAlign = props.dropdownAlign,
+      popupStyle = props.popupStyle,
+      transitionName = props.transitionName,
+      generateConfig = props.generateConfig,
+      locale = props.locale,
+      inputReadOnly = props.inputReadOnly,
+      allowClear = props.allowClear,
+      autoFocus = props.autoFocus,
+      showTime = props.showTime,
+      _props$picker = props.picker,
+      picker = _props$picker === void 0 ? 'date' : _props$picker,
+      format = props.format,
+      use12Hours = props.use12Hours,
+      value = props.value,
+      defaultValue = props.defaultValue,
+      open = props.open,
+      defaultOpen = props.defaultOpen,
+      defaultOpenValue = props.defaultOpenValue,
+      suffixIcon = props.suffixIcon,
+      clearIcon = props.clearIcon,
+      disabled = props.disabled,
+      disabledDate = props.disabledDate,
+      placeholder = props.placeholder,
+      getPopupContainer = props.getPopupContainer,
+      pickerRef = props.pickerRef,
+      onChange = props.onChange,
+      onOpenChange = props.onOpenChange,
+      onFocus = props.onFocus,
+      onBlur = props.onBlur,
+      onMouseDown = props.onMouseDown,
+      onMouseUp = props.onMouseUp,
+      onMouseEnter = props.onMouseEnter,
+      onMouseLeave = props.onMouseLeave,
+      onContextMenu = props.onContextMenu,
+      onClick = props.onClick,
+      direction = props.direction,
+      autoComplete = props.autoComplete;
+  var inputRef = React.useRef(null);
+  var needConfirmButton = picker === 'date' && !!showTime || picker === 'time'; // ============================= State =============================
+
+  var formatList = toArray(getDefaultFormat(format, picker, showTime, use12Hours)); // Panel ref
+
+  var panelDivRef = React.useRef(null);
+  var inputDivRef = React.useRef(null); // Real value
+
+  var _useMergedState = useMergedState(null, {
+    value: value,
+    defaultValue: defaultValue
+  }),
+      _useMergedState2 = _slicedToArray(_useMergedState, 2),
+      mergedValue = _useMergedState2[0],
+      setInnerValue = _useMergedState2[1]; // Selected value
+
+
+  var _React$useState = React.useState(mergedValue),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      selectedValue = _React$useState2[0],
+      setSelectedValue = _React$useState2[1]; // Operation ref
+
+
+  var operationRef = React.useRef(null); // Open
+
+  var _useMergedState3 = useMergedState(false, {
+    value: open,
+    defaultValue: defaultOpen,
+    postState: function postState(postOpen) {
+      return disabled ? false : postOpen;
+    },
+    onChange: function onChange(newOpen) {
+      if (onOpenChange) {
+        onOpenChange(newOpen);
+      }
+
+      if (!newOpen && operationRef.current && operationRef.current.onClose) {
+        operationRef.current.onClose();
+      }
+    }
+  }),
+      _useMergedState4 = _slicedToArray(_useMergedState3, 2),
+      mergedOpen = _useMergedState4[0],
+      triggerInnerOpen = _useMergedState4[1]; // ============================= Text ==============================
+
+
+  var valueTexts = useValueTexts(selectedValue, {
+    formatList: formatList,
+    generateConfig: generateConfig,
+    locale: locale
+  });
+
+  var _useTextValueMapping = useTextValueMapping({
+    valueTexts: valueTexts,
+    onTextChange: function onTextChange(newText) {
+      var inputDate = generateConfig.locale.parse(locale.locale, newText, formatList);
+
+      if (inputDate && (!disabledDate || !disabledDate(inputDate))) {
+        setSelectedValue(inputDate);
+      }
+    }
+  }),
+      _useTextValueMapping2 = _slicedToArray(_useTextValueMapping, 3),
+      text = _useTextValueMapping2[0],
+      triggerTextChange = _useTextValueMapping2[1],
+      resetText = _useTextValueMapping2[2]; // ============================ Trigger ============================
+
+
+  var triggerChange = function triggerChange(newValue) {
+    setSelectedValue(newValue);
+    setInnerValue(newValue);
+
+    if (onChange && !isEqual(generateConfig, mergedValue, newValue)) {
+      onChange(newValue, newValue ? generateConfig.locale.format(locale.locale, newValue, formatList[0]) : '');
+    }
+  };
+
+  var triggerOpen = function triggerOpen(newOpen) {
+    var preventChangeEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+    if (disabled && newOpen) {
+      return;
+    }
+
+    triggerInnerOpen(newOpen);
+
+    if (!newOpen && !preventChangeEvent) {
+      triggerChange(selectedValue);
+    }
+  };
+
+  var forwardKeyDown = function forwardKeyDown(e) {
+    if (mergedOpen && operationRef.current && operationRef.current.onKeyDown) {
+      // Let popup panel handle keyboard
+      return operationRef.current.onKeyDown(e);
+    }
+    /* istanbul ignore next */
+
+    /* eslint-disable no-lone-blocks */
+
+
+    {
+      warning(false, 'Picker not correct forward KeyDown operation. Please help to fire issue about this.');
+      return false;
+    }
+  };
+
+  var onInternalMouseUp = function onInternalMouseUp() {
+    if (onMouseUp) {
+      onMouseUp.apply(void 0, arguments);
+    }
+
+    if (inputRef.current) {
+      inputRef.current.focus();
+      triggerOpen(true);
+    }
+  }; // ============================= Input =============================
+
+
+  var _usePickerInput = usePickerInput({
+    blurToCancel: needConfirmButton,
+    open: mergedOpen,
+    triggerOpen: triggerOpen,
+    forwardKeyDown: forwardKeyDown,
+    isClickOutside: function isClickOutside(target) {
+      return !elementsContains([panelDivRef.current, inputDivRef.current], target);
+    },
+    onSubmit: function onSubmit() {
+      if (disabledDate && disabledDate(selectedValue)) {
+        return false;
+      }
+
+      triggerChange(selectedValue);
+      triggerOpen(false, true);
+      resetText();
+      return true;
+    },
+    onCancel: function onCancel() {
+      triggerOpen(false, true);
+      setSelectedValue(mergedValue);
+      resetText();
+    },
+    onFocus: onFocus,
+    onBlur: onBlur
+  }),
+      _usePickerInput2 = _slicedToArray(_usePickerInput, 2),
+      inputProps = _usePickerInput2[0],
+      _usePickerInput2$ = _usePickerInput2[1],
+      focused = _usePickerInput2$.focused,
+      typing = _usePickerInput2$.typing; // ============================= Sync ==============================
+  // Close should sync back with text value
+
+
+  React.useEffect(function () {
+    if (!mergedOpen) {
+      setSelectedValue(mergedValue);
+
+      if (!valueTexts.length || valueTexts[0] === '') {
+        triggerTextChange('');
+      } else if (!valueTexts.includes(text)) {
+        resetText();
+      }
+    }
+  }, [mergedOpen, valueTexts]); // Change picker should sync back with text value
+
+  React.useEffect(function () {
+    if (!mergedOpen) {
+      resetText();
+    }
+  }, [picker]); // Sync innerValue with control mode
+
+  React.useEffect(function () {
+    // Sync select value
+    setSelectedValue(mergedValue);
+  }, [mergedValue]); // ============================ Private ============================
+
+  if (pickerRef) {
+    pickerRef.current = {
+      focus: function focus() {
+        if (inputRef.current) {
+          inputRef.current.focus();
+        }
+      },
+      blur: function blur() {
+        if (inputRef.current) {
+          inputRef.current.blur();
+        }
+      }
+    };
+  } // ============================= Panel =============================
+
+
+  var panelProps = _objectSpread({}, props, {
+    className: undefined,
+    style: undefined,
+    pickerValue: undefined,
+    onPickerValueChange: undefined
+  });
+
+  var panel = React.createElement("div", {
+    className: "".concat(prefixCls, "-panel-container"),
+    onMouseDown: function onMouseDown(e) {
+      e.preventDefault();
+    }
+  }, React.createElement(PickerPanel, Object.assign({}, panelProps, {
+    generateConfig: generateConfig,
+    className: classNames(_defineProperty({}, "".concat(prefixCls, "-panel-focused"), !typing)),
+    value: selectedValue,
+    locale: locale,
+    tabIndex: -1,
+    onChange: setSelectedValue,
+    direction: direction
+  })));
+  var suffixNode;
+
+  if (suffixIcon) {
+    suffixNode = React.createElement("span", {
+      className: "".concat(prefixCls, "-suffix")
+    }, suffixIcon);
+  }
+
+  var clearNode;
+
+  if (allowClear && mergedValue && !disabled) {
+    clearNode = React.createElement("span", {
+      onMouseDown: function onMouseDown(e) {
+        e.preventDefault();
+        e.stopPropagation();
+      },
+      onMouseUp: function onMouseUp(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        triggerChange(null);
+        triggerOpen(false, true);
+      },
+      className: "".concat(prefixCls, "-clear")
+    }, clearIcon || React.createElement("span", {
+      className: "".concat(prefixCls, "-clear-btn")
+    }));
+  } // ============================ Warning ============================
+
+
+  if (process.env.NODE_ENV !== 'production') {
+    warning(!defaultOpenValue, '`defaultOpenValue` may confuse user for the current value status. Please use `defaultValue` instead.');
+  } // ============================ Return =============================
+
+
+  var onContextSelect = function onContextSelect(date, type) {
+    if (type === 'submit' || type !== 'key' && !needConfirmButton) {
+      // triggerChange will also update selected values
+      triggerChange(date);
+      triggerOpen(false, true);
+    }
+  };
+
+  var popupPlacement = direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
+  return React.createElement(PanelContext.Provider, {
+    value: {
+      operationRef: operationRef,
+      hideHeader: picker === 'time',
+      panelRef: panelDivRef,
+      onSelect: onContextSelect,
+      open: mergedOpen,
+      defaultOpenValue: defaultOpenValue
+    }
+  }, React.createElement(PickerTrigger, {
+    visible: mergedOpen,
+    popupElement: panel,
+    popupStyle: popupStyle,
+    prefixCls: prefixCls,
+    dropdownClassName: dropdownClassName,
+    dropdownAlign: dropdownAlign,
+    getPopupContainer: getPopupContainer,
+    transitionName: transitionName,
+    popupPlacement: popupPlacement,
+    direction: direction
+  }, React.createElement("div", {
+    className: classNames(prefixCls, className, (_classNames2 = {}, _defineProperty(_classNames2, "".concat(prefixCls, "-disabled"), disabled), _defineProperty(_classNames2, "".concat(prefixCls, "-focused"), focused), _defineProperty(_classNames2, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames2)),
+    style: style,
+    onMouseDown: onMouseDown,
+    onMouseUp: onInternalMouseUp,
+    onMouseEnter: onMouseEnter,
+    onMouseLeave: onMouseLeave,
+    onContextMenu: onContextMenu,
+    onClick: onClick
+  }, React.createElement("div", {
+    className: "".concat(prefixCls, "-input"),
+    ref: inputDivRef
+  }, React.createElement("input", Object.assign({
+    disabled: disabled,
+    readOnly: inputReadOnly || !typing,
+    value: text,
+    onChange: function onChange(e) {
+      triggerTextChange(e.target.value);
+    },
+    autoFocus: autoFocus,
+    placeholder: placeholder,
+    ref: inputRef,
+    title: text
+  }, inputProps, {
+    size: getInputSize(picker, formatList[0])
+  }, getDataOrAriaProps(props), {
+    autoComplete: autoComplete
+  })), suffixNode, clearNode))));
+} // Wrap with class component to enable pass generic with instance method
+
+
+var Picker = /*#__PURE__*/function (_React$Component) {
+  _inherits(Picker, _React$Component);
+
+  var _super = _createSuper(Picker);
+
+  function Picker() {
+    var _this;
+
+    _classCallCheck(this, Picker);
+
+    _this = _super.apply(this, arguments);
+    _this.pickerRef = React.createRef();
+
+    _this.focus = function () {
+      if (_this.pickerRef.current) {
+        _this.pickerRef.current.focus();
+      }
+    };
+
+    _this.blur = function () {
+      if (_this.pickerRef.current) {
+        _this.pickerRef.current.blur();
+      }
+    };
+
+    return _this;
+  }
+
+  _createClass(Picker, [{
+    key: "render",
+    value: function render() {
+      return React.createElement(InnerPicker, Object.assign({}, this.props, {
+        pickerRef: this.pickerRef
+      }));
+    }
+  }]);
+
+  return Picker;
+}(React.Component);
+
+export default Picker;

web/node_modules/rc-picker/es/PickerPanel.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Logic:
+ *  When `mode` === `picker`,
+ *  click will trigger `onSelect` (if value changed trigger `onChange` also).
+ *  Panel change will not trigger `onSelect` but trigger `onPanelChange`
+ */
+import * as React from 'react';
+import { SharedTimeProps } from './panels/TimePanel';
+import { GenerateConfig } from './generate';
+import { Locale, PanelMode, PickerMode, DisabledTime, OnPanelChange, Components } from './interface';
+import { DateRender } from './panels/DatePanel/DateBody';
+import { MonthCellRender } from './panels/MonthPanel/MonthBody';
+export interface PickerPanelSharedProps<DateType> {
+    prefixCls?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    /** @deprecated Will be removed in next big version. Please use `mode` instead */
+    mode?: PanelMode;
+    tabIndex?: number;
+    locale: Locale;
+    generateConfig: GenerateConfig<DateType>;
+    value?: DateType | null;
+    defaultValue?: DateType;
+    /** [Legacy] Set default display picker view date */
+    pickerValue?: DateType;
+    /** [Legacy] Set default display picker view date */
+    defaultPickerValue?: DateType;
+    disabledDate?: (date: DateType) => boolean;
+    dateRender?: DateRender<DateType>;
+    monthCellRender?: MonthCellRender<DateType>;
+    renderExtraFooter?: (mode: PanelMode) => React.ReactNode;
+    onSelect?: (value: DateType) => void;
+    onChange?: (value: DateType) => void;
+    onPanelChange?: OnPanelChange<DateType>;
+    onMouseDown?: React.MouseEventHandler<HTMLDivElement>;
+    onOk?: (date: DateType) => void;
+    direction?: 'ltr' | 'rtl';
+    /** @private This is internal usage. Do not use in your production env */
+    hideHeader?: boolean;
+    /** @private This is internal usage. Do not use in your production env */
+    onPickerValueChange?: (date: DateType) => void;
+    /** @private Internal usage. Do not use in your production env */
+    components?: Components;
+}
+export interface PickerPanelBaseProps<DateType> extends PickerPanelSharedProps<DateType> {
+    picker: Exclude<PickerMode, 'date' | 'time'>;
+}
+export interface PickerPanelDateProps<DateType> extends PickerPanelSharedProps<DateType> {
+    picker?: 'date';
+    showToday?: boolean;
+    showTime?: boolean | SharedTimeProps<DateType>;
+    disabledTime?: DisabledTime<DateType>;
+}
+export interface PickerPanelTimeProps<DateType> extends PickerPanelSharedProps<DateType>, SharedTimeProps<DateType> {
+    picker: 'time';
+}
+export declare type PickerPanelProps<DateType> = PickerPanelBaseProps<DateType> | PickerPanelDateProps<DateType> | PickerPanelTimeProps<DateType>;
+declare function PickerPanel<DateType>(props: PickerPanelProps<DateType>): JSX.Element;
+export default PickerPanel;

web/node_modules/rc-picker/es/PickerPanel.js

@@ -0,0 +1,399 @@
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+/* eslint-disable jsx-a11y/no-noninteractive-tabindex */
+
+/**
+ * Logic:
+ *  When `mode` === `picker`,
+ *  click will trigger `onSelect` (if value changed trigger `onChange` also).
+ *  Panel change will not trigger `onSelect` but trigger `onPanelChange`
+ */
+import * as React from 'react';
+import classNames from 'classnames';
+import KeyCode from "rc-util/es/KeyCode";
+import warning from "rc-util/es/warning";
+import useMergedState from "rc-util/es/hooks/useMergedState";
+import TimePanel from './panels/TimePanel';
+import DatetimePanel from './panels/DatetimePanel';
+import DatePanel from './panels/DatePanel';
+import WeekPanel from './panels/WeekPanel';
+import MonthPanel from './panels/MonthPanel';
+import QuarterPanel from './panels/QuarterPanel';
+import YearPanel from './panels/YearPanel';
+import DecadePanel from './panels/DecadePanel';
+import { isEqual } from './utils/dateUtil';
+import PanelContext from './PanelContext';
+import { PickerModeMap } from './utils/uiUtil';
+import RangeContext from './RangeContext';
+import getExtraFooter from './utils/getExtraFooter';
+import getRanges from './utils/getRanges';
+
+function PickerPanel(props) {
+  var _classNames;
+
+  var _props$prefixCls = props.prefixCls,
+      prefixCls = _props$prefixCls === void 0 ? 'rc-picker' : _props$prefixCls,
+      className = props.className,
+      style = props.style,
+      locale = props.locale,
+      generateConfig = props.generateConfig,
+      value = props.value,
+      defaultValue = props.defaultValue,
+      pickerValue = props.pickerValue,
+      defaultPickerValue = props.defaultPickerValue,
+      disabledDate = props.disabledDate,
+      mode = props.mode,
+      _props$picker = props.picker,
+      picker = _props$picker === void 0 ? 'date' : _props$picker,
+      _props$tabIndex = props.tabIndex,
+      tabIndex = _props$tabIndex === void 0 ? 0 : _props$tabIndex,
+      showTime = props.showTime,
+      showToday = props.showToday,
+      renderExtraFooter = props.renderExtraFooter,
+      hideHeader = props.hideHeader,
+      onSelect = props.onSelect,
+      onChange = props.onChange,
+      onPanelChange = props.onPanelChange,
+      onMouseDown = props.onMouseDown,
+      onPickerValueChange = props.onPickerValueChange,
+      _onOk = props.onOk,
+      components = props.components,
+      direction = props.direction;
+  var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
+
+  if (process.env.NODE_ENV !== 'production') {
+    warning(!value || generateConfig.isValidate(value), 'Invalidate date pass to `value`.');
+    warning(!value || generateConfig.isValidate(value), 'Invalidate date pass to `defaultValue`.');
+  } // ============================ State =============================
+
+
+  var panelContext = React.useContext(PanelContext);
+  var operationRef = panelContext.operationRef,
+      panelDivRef = panelContext.panelRef,
+      onContextSelect = panelContext.onSelect,
+      hideRanges = panelContext.hideRanges,
+      defaultOpenValue = panelContext.defaultOpenValue;
+
+  var _React$useContext = React.useContext(RangeContext),
+      inRange = _React$useContext.inRange,
+      panelPosition = _React$useContext.panelPosition,
+      rangedValue = _React$useContext.rangedValue,
+      hoverRangedValue = _React$useContext.hoverRangedValue;
+
+  var panelRef = React.useRef({}); // Handle init logic
+
+  var initRef = React.useRef(true); // Value
+
+  var _useMergedState = useMergedState(null, {
+    value: value,
+    defaultValue: defaultValue,
+    postState: function postState(val) {
+      if (!val && defaultOpenValue && picker === 'time') {
+        return defaultOpenValue;
+      }
+
+      return val;
+    }
+  }),
+      _useMergedState2 = _slicedToArray(_useMergedState, 2),
+      mergedValue = _useMergedState2[0],
+      setInnerValue = _useMergedState2[1]; // View date control
+
+
+  var _useMergedState3 = useMergedState(null, {
+    value: pickerValue,
+    defaultValue: defaultPickerValue || mergedValue,
+    postState: function postState(date) {
+      return date || generateConfig.getNow();
+    }
+  }),
+      _useMergedState4 = _slicedToArray(_useMergedState3, 2),
+      viewDate = _useMergedState4[0],
+      setInnerViewDate = _useMergedState4[1];
+
+  var setViewDate = function setViewDate(date) {
+    setInnerViewDate(date);
+
+    if (onPickerValueChange) {
+      onPickerValueChange(date);
+    }
+  }; // Panel control
+
+
+  var getInternalNextMode = function getInternalNextMode(nextMode) {
+    var getNextMode = PickerModeMap[picker];
+
+    if (getNextMode) {
+      return getNextMode(nextMode);
+    }
+
+    return nextMode;
+  }; // Save panel is changed from which panel
+
+
+  var _useMergedState5 = useMergedState(function () {
+    if (picker === 'time') {
+      return 'time';
+    }
+
+    return getInternalNextMode('date');
+  }, {
+    value: mode
+  }),
+      _useMergedState6 = _slicedToArray(_useMergedState5, 2),
+      mergedMode = _useMergedState6[0],
+      setInnerMode = _useMergedState6[1];
+
+  var _React$useState = React.useState(function () {
+    return mergedMode;
+  }),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      sourceMode = _React$useState2[0],
+      setSourceMode = _React$useState2[1];
+
+  var onInternalPanelChange = function onInternalPanelChange(newMode, viewValue) {
+    var nextMode = getInternalNextMode(newMode || mergedMode);
+    setSourceMode(mergedMode);
+    setInnerMode(nextMode);
+
+    if (onPanelChange && (mergedMode !== nextMode || isEqual(generateConfig, viewDate, viewDate))) {
+      onPanelChange(viewValue, nextMode);
+    }
+  };
+
+  var triggerSelect = function triggerSelect(date, type) {
+    var forceTriggerSelect = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    if (mergedMode === picker || forceTriggerSelect) {
+      setInnerValue(date);
+
+      if (onSelect) {
+        onSelect(date);
+      }
+
+      if (onContextSelect) {
+        onContextSelect(date, type);
+      }
+
+      if (onChange && !isEqual(generateConfig, date, mergedValue)) {
+        onChange(date);
+      }
+    }
+  }; // ========================= Interactive ==========================
+
+
+  var onInternalKeyDown = function onInternalKeyDown(e) {
+    if (panelRef.current && panelRef.current.onKeyDown) {
+      if ([KeyCode.LEFT, KeyCode.RIGHT, KeyCode.UP, KeyCode.DOWN, KeyCode.PAGE_UP, KeyCode.PAGE_DOWN, KeyCode.ENTER].includes(e.which)) {
+        e.preventDefault();
+      }
+
+      return panelRef.current.onKeyDown(e);
+    }
+    /* istanbul ignore next */
+
+    /* eslint-disable no-lone-blocks */
+
+
+    {
+      warning(false, 'Panel not correct handle keyDown event. Please help to fire issue about this.');
+      return false;
+    }
+    /* eslint-enable no-lone-blocks */
+  };
+
+  var onInternalBlur = function onInternalBlur(e) {
+    if (panelRef.current && panelRef.current.onBlur) {
+      panelRef.current.onBlur(e);
+    }
+  };
+
+  if (operationRef) {
+    operationRef.current = {
+      onKeyDown: onInternalKeyDown,
+      onClose: function onClose() {
+        if (panelRef.current && panelRef.current.onClose) {
+          panelRef.current.onClose();
+        }
+      }
+    };
+  } // ============================ Effect ============================
+
+
+  React.useEffect(function () {
+    if (value && !initRef.current) {
+      setInnerViewDate(value);
+    }
+  }, [value]);
+  React.useEffect(function () {
+    initRef.current = false;
+  }, []); // ============================ Panels ============================
+
+  var panelNode;
+
+  var pickerProps = _objectSpread({}, props, {
+    operationRef: panelRef,
+    prefixCls: prefixCls,
+    viewDate: viewDate,
+    value: mergedValue,
+    onViewDateChange: setViewDate,
+    sourceMode: sourceMode,
+    onPanelChange: onInternalPanelChange,
+    disabledDate: picker === mergedMode ? disabledDate : undefined
+  });
+
+  delete pickerProps.onChange;
+  delete pickerProps.onSelect;
+
+  switch (mergedMode) {
+    case 'decade':
+      panelNode = React.createElement(DecadePanel, Object.assign({}, pickerProps, {
+        onSelect: function onSelect(date, type) {
+          setViewDate(date);
+          triggerSelect(date, type);
+        }
+      }));
+      break;
+
+    case 'year':
+      panelNode = React.createElement(YearPanel, Object.assign({}, pickerProps, {
+        onSelect: function onSelect(date, type) {
+          setViewDate(date);
+          triggerSelect(date, type);
+        }
+      }));
+      break;
+
+    case 'month':
+      panelNode = React.createElement(MonthPanel, Object.assign({}, pickerProps, {
+        onSelect: function onSelect(date, type) {
+          setViewDate(date);
+          triggerSelect(date, type);
+        }
+      }));
+      break;
+
+    case 'quarter':
+      panelNode = React.createElement(QuarterPanel, Object.assign({}, pickerProps, {
+        onSelect: function onSelect(date, type) {
+          setViewDate(date);
+          triggerSelect(date, type);
+        }
+      }));
+      break;
+
+    case 'week':
+      panelNode = React.createElement(WeekPanel, Object.assign({}, pickerProps, {
+        onSelect: function onSelect(date, type) {
+          setViewDate(date);
+          triggerSelect(date, type);
+        }
+      }));
+      break;
+
+    case 'time':
+      delete pickerProps.showTime;
+      panelNode = React.createElement(TimePanel, Object.assign({}, pickerProps, _typeof(showTime) === 'object' ? showTime : null, {
+        onSelect: function onSelect(date, type) {
+          setViewDate(date);
+          triggerSelect(date, type);
+        }
+      }));
+      break;
+
+    default:
+      if (showTime) {
+        panelNode = React.createElement(DatetimePanel, Object.assign({}, pickerProps, {
+          onSelect: function onSelect(date, type) {
+            setViewDate(date);
+            triggerSelect(date, type);
+          }
+        }));
+      } else {
+        panelNode = React.createElement(DatePanel, Object.assign({}, pickerProps, {
+          onSelect: function onSelect(date, type) {
+            setViewDate(date);
+            triggerSelect(date, type);
+          }
+        }));
+      }
+
+  } // ============================ Footer ============================
+
+
+  var extraFooter;
+  var rangesNode;
+
+  if (!hideRanges) {
+    extraFooter = getExtraFooter(prefixCls, mergedMode, renderExtraFooter);
+    rangesNode = getRanges({
+      prefixCls: prefixCls,
+      components: components,
+      needConfirmButton: needConfirmButton,
+      okDisabled: !mergedValue || disabledDate && disabledDate(mergedValue),
+      locale: locale,
+      onNow: needConfirmButton && function () {
+        triggerSelect(generateConfig.getNow(), 'submit');
+      },
+      onOk: function onOk() {
+        if (mergedValue) {
+          triggerSelect(mergedValue, 'submit', true);
+
+          if (_onOk) {
+            _onOk(mergedValue);
+          }
+        }
+      }
+    });
+  }
+
+  var todayNode;
+
+  if (showToday && mergedMode === 'date' && picker === 'date' && !showTime) {
+    todayNode = React.createElement("a", {
+      className: "".concat(prefixCls, "-today-btn"),
+      onClick: function onClick() {
+        triggerSelect(generateConfig.getNow(), 'mouse', true);
+      }
+    }, locale.today);
+  }
+
+  return React.createElement(PanelContext.Provider, {
+    value: _objectSpread({}, panelContext, {
+      hideHeader: 'hideHeader' in props ? hideHeader : panelContext.hideHeader,
+      hidePrevBtn: inRange && panelPosition === 'right',
+      hideNextBtn: inRange && panelPosition === 'left'
+    })
+  }, React.createElement("div", {
+    tabIndex: tabIndex,
+    className: classNames("".concat(prefixCls, "-panel"), className, (_classNames = {}, _defineProperty(_classNames, "".concat(prefixCls, "-panel-has-range"), rangedValue && rangedValue[0] && rangedValue[1]), _defineProperty(_classNames, "".concat(prefixCls, "-panel-has-range-hover"), hoverRangedValue && hoverRangedValue[0] && hoverRangedValue[1]), _defineProperty(_classNames, "".concat(prefixCls, "-panel-rtl"), direction === 'rtl'), _classNames)),
+    style: style,
+    onKeyDown: onInternalKeyDown,
+    onBlur: onInternalBlur,
+    onMouseDown: onMouseDown,
+    ref: panelDivRef
+  }, panelNode, extraFooter || rangesNode || todayNode ? React.createElement("div", {
+    className: "".concat(prefixCls, "-footer")
+  }, extraFooter, rangesNode, todayNode) : null));
+}
+
+export default PickerPanel;
+/* eslint-enable */

web/node_modules/rc-picker/es/PickerTrigger.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { AlignType } from 'rc-trigger/lib/interface';
+declare type Placement = 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
+export interface PickerTriggerProps {
+    prefixCls: string;
+    visible: boolean;
+    popupElement: React.ReactElement;
+    popupStyle?: React.CSSProperties;
+    children: React.ReactElement;
+    dropdownClassName?: string;
+    transitionName?: string;
+    getPopupContainer?: (node: HTMLElement) => HTMLElement;
+    dropdownAlign?: AlignType;
+    range?: boolean;
+    popupPlacement?: Placement;
+    direction?: 'ltr' | 'rtl';
+}
+declare function PickerTrigger({ prefixCls, popupElement, popupStyle, visible, dropdownClassName, dropdownAlign, transitionName, getPopupContainer, children, range, popupPlacement, direction, }: PickerTriggerProps): JSX.Element;
+export default PickerTrigger;

web/node_modules/rc-picker/es/PickerTrigger.js

@@ -0,0 +1,82 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import * as React from 'react';
+import classNames from 'classnames';
+import Trigger from 'rc-trigger';
+var BUILT_IN_PLACEMENTS = {
+  bottomLeft: {
+    points: ['tl', 'bl'],
+    offset: [0, 4],
+    overflow: {
+      adjustX: 1,
+      adjustY: 1
+    }
+  },
+  bottomRight: {
+    points: ['tr', 'br'],
+    offset: [0, 4],
+    overflow: {
+      adjustX: 1,
+      adjustY: 1
+    }
+  },
+  topLeft: {
+    points: ['bl', 'tl'],
+    offset: [0, -4],
+    overflow: {
+      adjustX: 0,
+      adjustY: 1
+    }
+  },
+  topRight: {
+    points: ['br', 'tr'],
+    offset: [0, -4],
+    overflow: {
+      adjustX: 0,
+      adjustY: 1
+    }
+  }
+};
+
+function PickerTrigger(_ref) {
+  var _classNames;
+
+  var prefixCls = _ref.prefixCls,
+      popupElement = _ref.popupElement,
+      popupStyle = _ref.popupStyle,
+      visible = _ref.visible,
+      dropdownClassName = _ref.dropdownClassName,
+      dropdownAlign = _ref.dropdownAlign,
+      transitionName = _ref.transitionName,
+      getPopupContainer = _ref.getPopupContainer,
+      children = _ref.children,
+      range = _ref.range,
+      popupPlacement = _ref.popupPlacement,
+      direction = _ref.direction;
+  var dropdownPrefixCls = "".concat(prefixCls, "-dropdown");
+
+  var getPopupPlacement = function getPopupPlacement() {
+    if (popupPlacement !== undefined) {
+      return popupPlacement;
+    }
+
+    return direction === 'rtl' ? 'bottomRight' : 'bottomLeft';
+  };
+
+  return React.createElement(Trigger, {
+    showAction: [],
+    hideAction: [],
+    popupPlacement: getPopupPlacement(),
+    builtinPlacements: BUILT_IN_PLACEMENTS,
+    prefixCls: dropdownPrefixCls,
+    popupTransitionName: transitionName,
+    popup: popupElement,
+    popupAlign: dropdownAlign,
+    popupVisible: visible,
+    popupClassName: classNames(dropdownClassName, (_classNames = {}, _defineProperty(_classNames, "".concat(dropdownPrefixCls, "-range"), range), _defineProperty(_classNames, "".concat(dropdownPrefixCls, "-rtl"), direction === 'rtl'), _classNames)),
+    popupStyle: popupStyle,
+    getPopupContainer: getPopupContainer
+  }, children);
+}
+
+export default PickerTrigger;

web/node_modules/rc-picker/es/RangeContext.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { NullableDateType, RangeValue } from './interface';
+export interface RangeContextProps {
+    /**
+     * Set displayed range value style.
+     * Panel only has one value, this is only style effect.
+     */
+    rangedValue?: [NullableDateType<any>, NullableDateType<any>] | null;
+    hoverRangedValue?: RangeValue<any>;
+    inRange?: boolean;
+    panelPosition?: 'left' | 'right' | false;
+}
+declare const RangeContext: React.Context<RangeContextProps>;
+export default RangeContext;

web/node_modules/rc-picker/es/RangeContext.js

@@ -0,0 +1,3 @@
+import * as React from 'react';
+var RangeContext = React.createContext({});
+export default RangeContext;

web/node_modules/rc-picker/es/RangePicker.d.ts

@@ -0,0 +1,45 @@
+import * as React from 'react';
+import { DisabledTimes, PanelMode, RangeValue, EventValue } from './interface';
+import { PickerBaseProps, PickerDateProps, PickerTimeProps, PickerRefConfig } from './Picker';
+import { SharedTimeProps } from './panels/TimePanel';
+export interface RangePickerSharedProps<DateType> {
+    value?: RangeValue<DateType>;
+    defaultValue?: RangeValue<DateType>;
+    defaultPickerValue?: [DateType, DateType];
+    placeholder?: [string, string];
+    disabled?: boolean | [boolean, boolean];
+    disabledTime?: (date: EventValue<DateType>, type: 'start' | 'end') => DisabledTimes;
+    ranges?: Record<string, Exclude<RangeValue<DateType>, null> | (() => Exclude<RangeValue<DateType>, null>)>;
+    separator?: React.ReactNode;
+    allowEmpty?: [boolean, boolean];
+    mode?: [PanelMode, PanelMode];
+    onChange?: (values: RangeValue<DateType>, formatString: [string, string]) => void;
+    onCalendarChange?: (values: RangeValue<DateType>, formatString: [string, string]) => void;
+    onPanelChange?: (values: RangeValue<DateType>, modes: [PanelMode, PanelMode]) => void;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+    onOk?: (dates: RangeValue<DateType>) => void;
+    direction?: 'ltr' | 'rtl';
+    /** @private Internal control of active picker. Do not use since it's private usage */
+    activePickerIndex?: 0 | 1;
+}
+declare type OmitPickerProps<Props> = Omit<Props, 'value' | 'defaultValue' | 'defaultPickerValue' | 'placeholder' | 'disabled' | 'disabledTime' | 'showToday' | 'showTime' | 'mode' | 'onChange' | 'onSelect' | 'onPanelChange' | 'pickerValue' | 'onPickerValueChange' | 'onOk'>;
+declare type RangeShowTimeObject<DateType> = Omit<SharedTimeProps<DateType>, 'defaultValue'> & {
+    defaultValue?: DateType[];
+};
+export interface RangePickerBaseProps<DateType> extends RangePickerSharedProps<DateType>, OmitPickerProps<PickerBaseProps<DateType>> {
+}
+export interface RangePickerDateProps<DateType> extends RangePickerSharedProps<DateType>, OmitPickerProps<PickerDateProps<DateType>> {
+    showTime?: boolean | RangeShowTimeObject<DateType>;
+}
+export interface RangePickerTimeProps<DateType> extends RangePickerSharedProps<DateType>, OmitPickerProps<PickerTimeProps<DateType>> {
+    order?: boolean;
+}
+export declare type RangePickerProps<DateType> = RangePickerBaseProps<DateType> | RangePickerDateProps<DateType> | RangePickerTimeProps<DateType>;
+declare class RangePicker<DateType> extends React.Component<RangePickerProps<DateType>> {
+    pickerRef: React.RefObject<PickerRefConfig>;
+    focus: () => void;
+    blur: () => void;
+    render(): JSX.Element;
+}
+export default RangePicker;

web/node_modules/rc-picker/es/RangePicker.js

@@ -0,0 +1,886 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+import classNames from 'classnames';
+import warning from "rc-util/es/warning";
+import useMergedState from "rc-util/es/hooks/useMergedState";
+import PickerTrigger from './PickerTrigger';
+import PickerPanel from './PickerPanel';
+import usePickerInput from './hooks/usePickerInput';
+import getDataOrAriaProps, { toArray, getValue, updateValues } from './utils/miscUtil';
+import { getDefaultFormat, getInputSize, elementsContains } from './utils/uiUtil';
+import PanelContext from './PanelContext';
+import { isEqual, getClosingViewDate, isSameDate } from './utils/dateUtil';
+import useValueTexts from './hooks/useValueTexts';
+import useTextValueMapping from './hooks/useTextValueMapping';
+import RangeContext from './RangeContext';
+import useRangeDisabled from './hooks/useRangeDisabled';
+import getExtraFooter from './utils/getExtraFooter';
+import getRanges from './utils/getRanges';
+import useRangeViewDates from './hooks/useRangeViewDates';
+
+function reorderValues(values, generateConfig) {
+  if (values && values[0] && values[1] && generateConfig.isAfter(values[0], values[1])) {
+    return [values[1], values[0]];
+  }
+
+  return values;
+}
+
+function canValueTrigger(value, index, disabled, allowEmpty) {
+  if (value) {
+    return true;
+  }
+
+  if (allowEmpty && allowEmpty[index]) {
+    return true;
+  }
+
+  if (disabled[(index + 1) % 2]) {
+    return true;
+  }
+
+  return false;
+}
+
+function InnerRangePicker(props) {
+  var _classNames2;
+
+  var _props$prefixCls = props.prefixCls,
+      prefixCls = _props$prefixCls === void 0 ? 'rc-picker' : _props$prefixCls,
+      style = props.style,
+      className = props.className,
+      popupStyle = props.popupStyle,
+      dropdownClassName = props.dropdownClassName,
+      transitionName = props.transitionName,
+      dropdownAlign = props.dropdownAlign,
+      getPopupContainer = props.getPopupContainer,
+      generateConfig = props.generateConfig,
+      locale = props.locale,
+      placeholder = props.placeholder,
+      autoFocus = props.autoFocus,
+      disabled = props.disabled,
+      format = props.format,
+      _props$picker = props.picker,
+      picker = _props$picker === void 0 ? 'date' : _props$picker,
+      showTime = props.showTime,
+      use12Hours = props.use12Hours,
+      _props$separator = props.separator,
+      separator = _props$separator === void 0 ? '~' : _props$separator,
+      value = props.value,
+      defaultValue = props.defaultValue,
+      defaultPickerValue = props.defaultPickerValue,
+      open = props.open,
+      defaultOpen = props.defaultOpen,
+      disabledDate = props.disabledDate,
+      _disabledTime = props.disabledTime,
+      ranges = props.ranges,
+      allowEmpty = props.allowEmpty,
+      allowClear = props.allowClear,
+      suffixIcon = props.suffixIcon,
+      clearIcon = props.clearIcon,
+      pickerRef = props.pickerRef,
+      inputReadOnly = props.inputReadOnly,
+      mode = props.mode,
+      renderExtraFooter = props.renderExtraFooter,
+      onChange = props.onChange,
+      onOpenChange = props.onOpenChange,
+      onPanelChange = props.onPanelChange,
+      onCalendarChange = props.onCalendarChange,
+      _onFocus = props.onFocus,
+      onBlur = props.onBlur,
+      _onOk = props.onOk,
+      components = props.components,
+      order = props.order,
+      direction = props.direction,
+      activePickerIndex = props.activePickerIndex;
+  var needConfirmButton = picker === 'date' && !!showTime || picker === 'time';
+  var containerRef = React.useRef(null);
+  var panelDivRef = React.useRef(null);
+  var startInputDivRef = React.useRef(null);
+  var endInputDivRef = React.useRef(null);
+  var separatorRef = React.useRef(null);
+  var startInputRef = React.useRef(null);
+  var endInputRef = React.useRef(null); // ============================= Misc ==============================
+
+  var formatList = toArray(getDefaultFormat(format, picker, showTime, use12Hours)); // Active picker
+
+  var _useMergedState = useMergedState(0, {
+    value: activePickerIndex
+  }),
+      _useMergedState2 = _slicedToArray(_useMergedState, 2),
+      mergedActivePickerIndex = _useMergedState2[0],
+      setMergedActivePickerIndex = _useMergedState2[1]; // Operation ref
+
+
+  var operationRef = React.useRef(null);
+  var mergedDisabled = React.useMemo(function () {
+    if (Array.isArray(disabled)) {
+      return disabled;
+    }
+
+    return [disabled || false, disabled || false];
+  }, [disabled]); // ============================= Value =============================
+
+  var _useMergedState3 = useMergedState(null, {
+    value: value,
+    defaultValue: defaultValue,
+    postState: function postState(values) {
+      return picker === 'time' && !order ? values : reorderValues(values, generateConfig);
+    }
+  }),
+      _useMergedState4 = _slicedToArray(_useMergedState3, 2),
+      mergedValue = _useMergedState4[0],
+      setInnerValue = _useMergedState4[1]; // =========================== View Date ===========================
+  // Config view panel
+
+
+  var _useRangeViewDates = useRangeViewDates({
+    values: mergedValue,
+    picker: picker,
+    defaultDates: defaultPickerValue,
+    generateConfig: generateConfig
+  }),
+      _useRangeViewDates2 = _slicedToArray(_useRangeViewDates, 2),
+      getViewDate = _useRangeViewDates2[0],
+      setViewDate = _useRangeViewDates2[1]; // ========================= Select Values =========================
+
+
+  var _useMergedState5 = useMergedState(mergedValue, {
+    postState: function postState(values) {
+      var postValues = values;
+
+      for (var i = 0; i < 2; i += 1) {
+        if (mergedDisabled[i] && !getValue(postValues, i) && !getValue(allowEmpty, i)) {
+          postValues = updateValues(postValues, generateConfig.getNow(), i);
+        }
+      }
+
+      return postValues;
+    }
+  }),
+      _useMergedState6 = _slicedToArray(_useMergedState5, 2),
+      selectedValue = _useMergedState6[0],
+      setSelectedValue = _useMergedState6[1];
+
+  var _React$useState = React.useState(null),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      rangeHoverValue = _React$useState2[0],
+      setRangeHoverValue = _React$useState2[1]; // ========================== Hover Range ==========================
+
+
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      hoverRangedValue = _React$useState4[0],
+      setHoverRangedValue = _React$useState4[1];
+
+  var onDateMouseEnter = function onDateMouseEnter(date) {
+    setHoverRangedValue(updateValues(selectedValue, date, mergedActivePickerIndex));
+  };
+
+  var onDateMouseLeave = function onDateMouseLeave() {
+    setHoverRangedValue(updateValues(selectedValue, null, mergedActivePickerIndex));
+  }; // ============================= Modes =============================
+
+
+  var _useMergedState7 = useMergedState([picker, picker], {
+    value: mode
+  }),
+      _useMergedState8 = _slicedToArray(_useMergedState7, 2),
+      mergedModes = _useMergedState8[0],
+      setInnerModes = _useMergedState8[1];
+
+  React.useEffect(function () {
+    setInnerModes([picker, picker]);
+  }, [picker]);
+
+  var triggerModesChange = function triggerModesChange(modes, values) {
+    setInnerModes(modes);
+
+    if (onPanelChange) {
+      onPanelChange(values, modes);
+    }
+  }; // ========================= Disable Date ==========================
+
+
+  var _useRangeDisabled = useRangeDisabled({
+    picker: picker,
+    selectedValue: selectedValue,
+    locale: locale,
+    disabled: mergedDisabled,
+    disabledDate: disabledDate,
+    generateConfig: generateConfig
+  }),
+      _useRangeDisabled2 = _slicedToArray(_useRangeDisabled, 2),
+      disabledStartDate = _useRangeDisabled2[0],
+      disabledEndDate = _useRangeDisabled2[1]; // ============================= Open ==============================
+
+
+  var _useMergedState9 = useMergedState(false, {
+    value: open,
+    defaultValue: defaultOpen,
+    postState: function postState(postOpen) {
+      return mergedDisabled[mergedActivePickerIndex] ? false : postOpen;
+    },
+    onChange: function onChange(newOpen) {
+      if (onOpenChange) {
+        onOpenChange(newOpen);
+      }
+
+      if (!newOpen && operationRef.current && operationRef.current.onClose) {
+        operationRef.current.onClose();
+      }
+    }
+  }),
+      _useMergedState10 = _slicedToArray(_useMergedState9, 2),
+      mergedOpen = _useMergedState10[0],
+      triggerInnerOpen = _useMergedState10[1];
+
+  var startOpen = mergedOpen && mergedActivePickerIndex === 0;
+  var endOpen = mergedOpen && mergedActivePickerIndex === 1; // ============================= Popup =============================
+  // Popup min width
+
+  var _React$useState5 = React.useState(0),
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      popupMinWidth = _React$useState6[0],
+      setPopupMinWidth = _React$useState6[1];
+
+  React.useEffect(function () {
+    if (!mergedOpen && containerRef.current) {
+      setPopupMinWidth(containerRef.current.offsetWidth);
+    }
+  }, [mergedOpen]); // ============================ Trigger ============================
+
+  var _triggerOpen;
+
+  var triggerChange = function triggerChange(newValue) {
+    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var _config$forceInput = config.forceInput,
+        forceInput = _config$forceInput === void 0 ? true : _config$forceInput,
+        source = config.source;
+    var values = newValue;
+    var startValue = getValue(values, 0);
+    var endValue = getValue(values, 1);
+
+    if (startValue && endValue && generateConfig.isAfter(startValue, endValue)) {
+      if (!isSameDate(generateConfig, startValue, endValue)) {
+        // Clean up end date when start date is after end date
+        values = [startValue, null];
+        endValue = null;
+      } else if (picker !== 'time' || order !== false) {
+        // Reorder when in same date
+        values = reorderValues(values, generateConfig);
+      }
+    }
+
+    setSelectedValue(values);
+    var startStr = values && values[0] ? generateConfig.locale.format(locale.locale, values[0], formatList[0]) : '';
+    var endStr = values && values[1] ? generateConfig.locale.format(locale.locale, values[1], formatList[0]) : '';
+
+    if (onCalendarChange) {
+      onCalendarChange(values, [startStr, endStr]);
+    }
+
+    var canStartValueTrigger = canValueTrigger(startValue, 0, mergedDisabled, allowEmpty);
+    var canEndValueTrigger = canValueTrigger(endValue, 1, mergedDisabled, allowEmpty);
+    var canTrigger = values === null || canStartValueTrigger && canEndValueTrigger;
+
+    if (canTrigger) {
+      // Trigger onChange only when value is validate
+      setInnerValue(values);
+
+      if (source !== 'open') {
+        _triggerOpen(false, mergedActivePickerIndex, true);
+      }
+
+      if (onChange && (!isEqual(generateConfig, getValue(mergedValue, 0), startValue) || !isEqual(generateConfig, getValue(mergedValue, 1), endValue))) {
+        onChange(values, [startStr, endStr]);
+      }
+    } else if (forceInput) {
+      // Open miss value panel to force user input
+      var missingValueIndex = canStartValueTrigger ? 1 : 0; // Same index means user choice to close picker
+
+      if (missingValueIndex === mergedActivePickerIndex) {
+        return;
+      }
+
+      if (source !== 'open') {
+        _triggerOpen(true, missingValueIndex);
+      } // Delay to focus to avoid input blur trigger expired selectedValues
+
+
+      setTimeout(function () {
+        var inputRef = [startInputRef, endInputRef][missingValueIndex];
+
+        if (inputRef.current) {
+          inputRef.current.focus();
+        }
+      }, 0);
+    }
+  };
+
+  _triggerOpen = function triggerOpen(newOpen, index) {
+    var preventChangeEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    if (newOpen) {
+      setMergedActivePickerIndex(index);
+      triggerInnerOpen(newOpen); // Open to reset view date
+
+      if (!mergedOpen) {
+        setViewDate(null, index);
+      }
+    } else if (mergedActivePickerIndex === index) {
+      triggerInnerOpen(newOpen);
+
+      if (!preventChangeEvent) {
+        triggerChange(selectedValue, {
+          source: 'open'
+        });
+      }
+    }
+  };
+
+  var forwardKeyDown = function forwardKeyDown(e) {
+    if (mergedOpen && operationRef.current && operationRef.current.onKeyDown) {
+      // Let popup panel handle keyboard
+      return operationRef.current.onKeyDown(e);
+    }
+    /* istanbul ignore next */
+
+    /* eslint-disable no-lone-blocks */
+
+
+    {
+      warning(false, 'Picker not correct forward KeyDown operation. Please help to fire issue about this.');
+      return false;
+    }
+  }; // ============================= Text ==============================
+
+
+  var sharedTextHooksProps = {
+    formatList: formatList,
+    generateConfig: generateConfig,
+    locale: locale
+  };
+  var startValueTexts = useValueTexts(getValue(selectedValue, 0), sharedTextHooksProps);
+  var endValueTexts = useValueTexts(getValue(selectedValue, 1), sharedTextHooksProps);
+
+  var _onTextChange = function onTextChange(newText, index) {
+    var inputDate = generateConfig.locale.parse(locale.locale, newText, formatList);
+    var disabledFunc = index === 0 ? disabledStartDate : disabledEndDate;
+
+    if (inputDate && !disabledFunc(inputDate)) {
+      setSelectedValue(updateValues(selectedValue, inputDate, index));
+      setViewDate(inputDate, index);
+    }
+  };
+
+  var _useTextValueMapping = useTextValueMapping({
+    valueTexts: startValueTexts,
+    onTextChange: function onTextChange(newText) {
+      return _onTextChange(newText, 0);
+    }
+  }),
+      _useTextValueMapping2 = _slicedToArray(_useTextValueMapping, 3),
+      startText = _useTextValueMapping2[0],
+      triggerStartTextChange = _useTextValueMapping2[1],
+      resetStartText = _useTextValueMapping2[2];
+
+  var _useTextValueMapping3 = useTextValueMapping({
+    valueTexts: endValueTexts,
+    onTextChange: function onTextChange(newText) {
+      return _onTextChange(newText, 1);
+    }
+  }),
+      _useTextValueMapping4 = _slicedToArray(_useTextValueMapping3, 3),
+      endText = _useTextValueMapping4[0],
+      triggerEndTextChange = _useTextValueMapping4[1],
+      resetEndText = _useTextValueMapping4[2]; // ============================= Input =============================
+
+
+  var getSharedInputHookProps = function getSharedInputHookProps(index, resetText) {
+    return {
+      blurToCancel: needConfirmButton,
+      forwardKeyDown: forwardKeyDown,
+      onBlur: onBlur,
+      isClickOutside: function isClickOutside(target) {
+        return !elementsContains([panelDivRef.current, startInputDivRef.current, endInputDivRef.current], target);
+      },
+      onFocus: function onFocus(e) {
+        setMergedActivePickerIndex(index);
+
+        if (_onFocus) {
+          _onFocus(e);
+        }
+      },
+      triggerOpen: function triggerOpen(newOpen) {
+        return _triggerOpen(newOpen, index);
+      },
+      onSubmit: function onSubmit() {
+        triggerChange(selectedValue);
+        resetText();
+      },
+      onCancel: function onCancel() {
+        _triggerOpen(false, index, true);
+
+        setSelectedValue(mergedValue);
+        resetText();
+      }
+    };
+  };
+
+  var _usePickerInput = usePickerInput(_objectSpread({}, getSharedInputHookProps(0, resetStartText), {
+    open: startOpen
+  })),
+      _usePickerInput2 = _slicedToArray(_usePickerInput, 2),
+      startInputProps = _usePickerInput2[0],
+      _usePickerInput2$ = _usePickerInput2[1],
+      startFocused = _usePickerInput2$.focused,
+      startTyping = _usePickerInput2$.typing;
+
+  var _usePickerInput3 = usePickerInput(_objectSpread({}, getSharedInputHookProps(1, resetEndText), {
+    open: endOpen
+  })),
+      _usePickerInput4 = _slicedToArray(_usePickerInput3, 2),
+      endInputProps = _usePickerInput4[0],
+      _usePickerInput4$ = _usePickerInput4[1],
+      endFocused = _usePickerInput4$.focused,
+      endTyping = _usePickerInput4$.typing; // ============================= Sync ==============================
+  // Close should sync back with text value
+
+
+  var startStr = mergedValue && mergedValue[0] ? generateConfig.locale.format(locale.locale, mergedValue[0], 'YYYYMMDDHHmmss') : '';
+  var endStr = mergedValue && mergedValue[1] ? generateConfig.locale.format(locale.locale, mergedValue[1], 'YYYYMMDDHHmmss') : '';
+  React.useEffect(function () {
+    if (!mergedOpen) {
+      setSelectedValue(mergedValue);
+
+      if (!startValueTexts.length || startValueTexts[0] === '') {
+        triggerStartTextChange('');
+      } else if (!startValueTexts.includes(startText)) {
+        resetStartText();
+      }
+
+      if (!endValueTexts.length || endValueTexts[0] === '') {
+        triggerEndTextChange('');
+      } else if (!endValueTexts.includes(endText)) {
+        resetEndText();
+      }
+    }
+  }, [mergedOpen, startValueTexts, endValueTexts]); // Sync innerValue with control mode
+
+  React.useEffect(function () {
+    setSelectedValue(mergedValue);
+  }, [startStr, endStr]); // ============================ Warning ============================
+
+  if (process.env.NODE_ENV !== 'production') {
+    if (value && Array.isArray(disabled) && (getValue(disabled, 0) && !getValue(value, 0) || getValue(disabled, 1) && !getValue(value, 1))) {
+      warning(false, '`disabled` should not set with empty `value`. You should set `allowEmpty` or `value` instead.');
+    }
+  } // ============================ Private ============================
+
+
+  if (pickerRef) {
+    pickerRef.current = {
+      focus: function focus() {
+        if (startInputRef.current) {
+          startInputRef.current.focus();
+        }
+      },
+      blur: function blur() {
+        if (startInputRef.current) {
+          startInputRef.current.blur();
+        }
+
+        if (endInputRef.current) {
+          endInputRef.current.blur();
+        }
+      }
+    };
+  } // ============================ Ranges =============================
+
+
+  var rangeLabels = Object.keys(ranges || {});
+  var rangeList = rangeLabels.map(function (label) {
+    var range = ranges[label];
+    var newValues = typeof range === 'function' ? range() : range;
+    return {
+      label: label,
+      onClick: function onClick() {
+        triggerChange(newValues);
+      },
+      onMouseEnter: function onMouseEnter() {
+        setRangeHoverValue(newValues);
+      },
+      onMouseLeave: function onMouseLeave() {
+        setRangeHoverValue(null);
+      }
+    };
+  }); // ============================= Panel =============================
+
+  function renderPanel() {
+    var panelPosition = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var panelProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var panelHoverRangedValue = null;
+
+    if (mergedOpen && hoverRangedValue && hoverRangedValue[0] && hoverRangedValue[1] && generateConfig.isAfter(hoverRangedValue[1], hoverRangedValue[0])) {
+      panelHoverRangedValue = hoverRangedValue;
+    }
+
+    var panelShowTime = showTime;
+
+    if (showTime && _typeof(showTime) === 'object' && showTime.defaultValue) {
+      var timeDefaultValues = showTime.defaultValue;
+      panelShowTime = _objectSpread({}, showTime, {
+        defaultValue: getValue(timeDefaultValues, mergedActivePickerIndex) || undefined
+      });
+    }
+
+    return React.createElement(RangeContext.Provider, {
+      value: {
+        inRange: true,
+        panelPosition: panelPosition,
+        rangedValue: rangeHoverValue || selectedValue,
+        hoverRangedValue: panelHoverRangedValue
+      }
+    }, React.createElement(PickerPanel, Object.assign({}, props, panelProps, {
+      showTime: panelShowTime,
+      mode: mergedModes[mergedActivePickerIndex],
+      generateConfig: generateConfig,
+      style: undefined,
+      direction: direction,
+      disabledDate: mergedActivePickerIndex === 0 ? disabledStartDate : disabledEndDate,
+      disabledTime: function disabledTime(date) {
+        if (_disabledTime) {
+          return _disabledTime(date, mergedActivePickerIndex === 0 ? 'start' : 'end');
+        }
+
+        return false;
+      },
+      className: classNames(_defineProperty({}, "".concat(prefixCls, "-panel-focused"), mergedActivePickerIndex === 0 ? !startTyping : !endTyping)),
+      value: getValue(selectedValue, mergedActivePickerIndex),
+      locale: locale,
+      tabIndex: -1,
+      onPanelChange: function onPanelChange(date, newMode) {
+        triggerModesChange(updateValues(mergedModes, newMode, mergedActivePickerIndex), updateValues(selectedValue, date, mergedActivePickerIndex));
+        var viewDate = date;
+
+        if (panelPosition === 'right') {
+          viewDate = getClosingViewDate(viewDate, newMode, generateConfig, -1);
+        }
+
+        setViewDate(viewDate, mergedActivePickerIndex);
+      },
+      onOk: null,
+      onSelect: undefined,
+      onChange: undefined,
+      defaultValue: undefined,
+      defaultPickerValue: undefined
+    })));
+  }
+
+  var arrowLeft = 0;
+  var panelLeft = 0;
+
+  if (mergedActivePickerIndex && startInputDivRef.current && separatorRef.current && panelDivRef.current) {
+    // Arrow offset
+    arrowLeft = startInputDivRef.current.offsetWidth + separatorRef.current.offsetWidth;
+
+    if (panelDivRef.current.offsetWidth && arrowLeft > panelDivRef.current.offsetWidth) {
+      panelLeft = arrowLeft;
+    }
+  }
+
+  var arrowPositionStyle = direction === 'rtl' ? {
+    right: arrowLeft
+  } : {
+    left: arrowLeft
+  };
+
+  function renderPanels() {
+    var panels;
+    var extraNode = getExtraFooter(prefixCls, mergedModes[mergedActivePickerIndex], renderExtraFooter);
+    var rangesNode = getRanges({
+      prefixCls: prefixCls,
+      components: components,
+      needConfirmButton: needConfirmButton,
+      okDisabled: !getValue(selectedValue, mergedActivePickerIndex),
+      locale: locale,
+      rangeList: rangeList,
+      onOk: function onOk() {
+        if (getValue(selectedValue, mergedActivePickerIndex)) {
+          triggerChange(selectedValue);
+
+          if (_onOk) {
+            _onOk(selectedValue);
+          }
+        }
+      }
+    });
+
+    if (picker !== 'time' && !showTime) {
+      var viewDate = getViewDate(mergedActivePickerIndex);
+      var nextViewDate = getClosingViewDate(viewDate, picker, generateConfig);
+      var currentMode = mergedModes[mergedActivePickerIndex];
+      var showDoublePanel = currentMode === picker;
+      var leftPanel = renderPanel(showDoublePanel ? 'left' : false, {
+        pickerValue: viewDate,
+        onPickerValueChange: function onPickerValueChange(newViewDate) {
+          setViewDate(newViewDate, mergedActivePickerIndex);
+        }
+      });
+      var rightPanel = renderPanel('right', {
+        pickerValue: nextViewDate,
+        onPickerValueChange: function onPickerValueChange(newViewDate) {
+          setViewDate(getClosingViewDate(newViewDate, picker, generateConfig, -1), mergedActivePickerIndex);
+        }
+      });
+
+      if (direction === 'rtl') {
+        panels = React.createElement(React.Fragment, null, rightPanel, showDoublePanel && leftPanel);
+      } else {
+        panels = React.createElement(React.Fragment, null, leftPanel, showDoublePanel && rightPanel);
+      }
+    } else {
+      panels = renderPanel();
+    }
+
+    return React.createElement("div", {
+      className: "".concat(prefixCls, "-panel-container"),
+      style: {
+        marginLeft: panelLeft
+      },
+      ref: panelDivRef,
+      onMouseDown: function onMouseDown(e) {
+        e.preventDefault();
+      }
+    }, React.createElement("div", {
+      className: "".concat(prefixCls, "-panels")
+    }, panels), (extraNode || rangesNode) && React.createElement("div", {
+      className: "".concat(prefixCls, "-footer")
+    }, extraNode, rangesNode));
+  }
+
+  var rangePanel = React.createElement("div", {
+    className: classNames("".concat(prefixCls, "-range-wrapper"), "".concat(prefixCls, "-").concat(picker, "-range-wrapper")),
+    style: {
+      minWidth: popupMinWidth
+    }
+  }, React.createElement("div", {
+    className: "".concat(prefixCls, "-range-arrow"),
+    style: arrowPositionStyle
+  }), renderPanels()); // ============================= Icons =============================
+
+  var suffixNode;
+
+  if (suffixIcon) {
+    suffixNode = React.createElement("span", {
+      className: "".concat(prefixCls, "-suffix")
+    }, suffixIcon);
+  }
+
+  var clearNode;
+
+  if (allowClear && (getValue(mergedValue, 0) && !mergedDisabled[0] || getValue(mergedValue, 1) && !mergedDisabled[1])) {
+    clearNode = React.createElement("span", {
+      onMouseDown: function onMouseDown(e) {
+        e.preventDefault();
+        e.stopPropagation();
+      },
+      onMouseUp: function onMouseUp(e) {
+        e.preventDefault();
+        e.stopPropagation();
+        var values = mergedValue;
+
+        if (!mergedDisabled[0]) {
+          values = updateValues(values, null, 0);
+        }
+
+        if (!mergedDisabled[1]) {
+          values = updateValues(values, null, 1);
+        }
+
+        triggerChange(values, {
+          forceInput: false
+        });
+      },
+      className: "".concat(prefixCls, "-clear")
+    }, clearIcon || React.createElement("span", {
+      className: "".concat(prefixCls, "-clear-btn")
+    }));
+  }
+
+  var inputSharedProps = {
+    size: getInputSize(picker, formatList[0])
+  };
+  var activeBarLeft = 0;
+  var activeBarWidth = 0;
+
+  if (startInputDivRef.current && endInputDivRef.current && separatorRef.current) {
+    if (mergedActivePickerIndex === 0) {
+      activeBarWidth = startInputDivRef.current.offsetWidth;
+    } else {
+      activeBarLeft = arrowLeft;
+      activeBarWidth = endInputDivRef.current.offsetWidth;
+    }
+  }
+
+  var activeBarPositionStyle = direction === 'rtl' ? {
+    right: activeBarLeft
+  } : {
+    left: activeBarLeft
+  }; // ============================ Return =============================
+
+  var onContextSelect = function onContextSelect(date, type) {
+    var values = updateValues(selectedValue, date, mergedActivePickerIndex);
+
+    if (type === 'submit' || type !== 'key' && !needConfirmButton) {
+      // triggerChange will also update selected values
+      triggerChange(values);
+    } else {
+      setSelectedValue(values);
+    }
+  };
+
+  return React.createElement(PanelContext.Provider, {
+    value: {
+      operationRef: operationRef,
+      hideHeader: picker === 'time',
+      onDateMouseEnter: onDateMouseEnter,
+      onDateMouseLeave: onDateMouseLeave,
+      hideRanges: true,
+      onSelect: onContextSelect,
+      open: mergedOpen
+    }
+  }, React.createElement(PickerTrigger, {
+    visible: mergedOpen,
+    popupElement: rangePanel,
+    popupStyle: popupStyle,
+    prefixCls: prefixCls,
+    dropdownClassName: dropdownClassName,
+    dropdownAlign: dropdownAlign,
+    getPopupContainer: getPopupContainer,
+    transitionName: transitionName,
+    range: true,
+    direction: direction
+  }, React.createElement("div", Object.assign({
+    ref: containerRef,
+    className: classNames(prefixCls, "".concat(prefixCls, "-range"), className, (_classNames2 = {}, _defineProperty(_classNames2, "".concat(prefixCls, "-disabled"), mergedDisabled[0] && mergedDisabled[1]), _defineProperty(_classNames2, "".concat(prefixCls, "-focused"), mergedActivePickerIndex === 0 ? startFocused : endFocused), _defineProperty(_classNames2, "".concat(prefixCls, "-rtl"), direction === 'rtl'), _classNames2)),
+    style: style
+  }, getDataOrAriaProps(props)), React.createElement("div", {
+    className: classNames("".concat(prefixCls, "-input"), _defineProperty({}, "".concat(prefixCls, "-input-active"), mergedActivePickerIndex === 0)),
+    ref: startInputDivRef
+  }, React.createElement("input", Object.assign({
+    disabled: mergedDisabled[0],
+    readOnly: inputReadOnly || !startTyping,
+    value: startText,
+    onChange: function onChange(e) {
+      triggerStartTextChange(e.target.value);
+    },
+    autoFocus: autoFocus,
+    placeholder: getValue(placeholder, 0) || '',
+    ref: startInputRef
+  }, startInputProps, inputSharedProps))), React.createElement("div", {
+    className: "".concat(prefixCls, "-range-separator"),
+    ref: separatorRef
+  }, separator), React.createElement("div", {
+    className: classNames("".concat(prefixCls, "-input"), _defineProperty({}, "".concat(prefixCls, "-input-active"), mergedActivePickerIndex === 1)),
+    ref: endInputDivRef
+  }, React.createElement("input", Object.assign({
+    disabled: mergedDisabled[1],
+    readOnly: inputReadOnly || !endTyping,
+    value: endText,
+    onChange: function onChange(e) {
+      triggerEndTextChange(e.target.value);
+    },
+    placeholder: getValue(placeholder, 1) || '',
+    ref: endInputRef
+  }, endInputProps, inputSharedProps))), React.createElement("div", {
+    className: "".concat(prefixCls, "-active-bar"),
+    style: _objectSpread({}, activeBarPositionStyle, {
+      width: activeBarWidth,
+      position: 'absolute'
+    })
+  }), suffixNode, clearNode)));
+} // Wrap with class component to enable pass generic with instance method
+
+
+var RangePicker = /*#__PURE__*/function (_React$Component) {
+  _inherits(RangePicker, _React$Component);
+
+  var _super = _createSuper(RangePicker);
+
+  function RangePicker() {
+    var _this;
+
+    _classCallCheck(this, RangePicker);
+
+    _this = _super.apply(this, arguments);
+    _this.pickerRef = React.createRef();
+
+    _this.focus = function () {
+      if (_this.pickerRef.current) {
+        _this.pickerRef.current.focus();
+      }
+    };
+
+    _this.blur = function () {
+      if (_this.pickerRef.current) {
+        _this.pickerRef.current.blur();
+      }
+    };
+
+    return _this;
+  }
+
+  _createClass(RangePicker, [{
+    key: "render",
+    value: function render() {
+      return React.createElement(InnerRangePicker, Object.assign({}, this.props, {
+        pickerRef: this.pickerRef
+      }));
+    }
+  }]);
+
+  return RangePicker;
+}(React.Component);
+
+export default RangePicker;

web/node_modules/rc-picker/es/generate/dayjs.d.ts

@@ -0,0 +1,4 @@
+import { Dayjs } from 'dayjs';
+import { GenerateConfig } from '.';
+declare const generateConfig: GenerateConfig<Dayjs>;
+export default generateConfig;

web/node_modules/rc-picker/es/generate/dayjs.js

@@ -0,0 +1,156 @@
+import dayjs from 'dayjs';
+import { noteOnce } from "rc-util/es/warning";
+import weekday from 'dayjs/plugin/weekday';
+import localeData from 'dayjs/plugin/localeData';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+import weekYear from 'dayjs/plugin/weekYear';
+import advancedFormat from 'dayjs/plugin/advancedFormat';
+import customParseFormat from 'dayjs/plugin/customParseFormat';
+dayjs.extend(customParseFormat);
+dayjs.extend(advancedFormat);
+dayjs.extend(weekday);
+dayjs.extend(localeData);
+dayjs.extend(weekOfYear);
+dayjs.extend(weekYear);
+dayjs.extend(function (o, c) {
+  // todo support Wo (ISO week)
+  var proto = c.prototype;
+  var oldFormat = proto.format;
+
+  proto.format = function f(formatStr) {
+    var str = (formatStr || '').replace('Wo', 'wo');
+    return oldFormat.bind(this)(str);
+  };
+});
+var localeMap = {
+  en_GB: 'en-gb',
+  en_US: 'en',
+  zh_CN: 'zh-cn',
+  zh_TW: 'zh-tw'
+};
+
+var parseLocale = function parseLocale(locale) {
+  var mapLocale = localeMap[locale];
+  return mapLocale || locale.split('_')[0];
+};
+
+var parseNoMatchNotice = function parseNoMatchNotice() {
+  /* istanbul ignore next */
+  noteOnce(false, 'Not match any format. Please help to fire a issue about this.');
+};
+
+var generateConfig = {
+  // get
+  getNow: function getNow() {
+    return dayjs();
+  },
+  getWeekDay: function getWeekDay(date) {
+    return date.weekday();
+  },
+  getYear: function getYear(date) {
+    return date.year();
+  },
+  getMonth: function getMonth(date) {
+    return date.month();
+  },
+  getDate: function getDate(date) {
+    return date.date();
+  },
+  getHour: function getHour(date) {
+    return date.hour();
+  },
+  getMinute: function getMinute(date) {
+    return date.minute();
+  },
+  getSecond: function getSecond(date) {
+    return date.second();
+  },
+  // set
+  addYear: function addYear(date, diff) {
+    return date.add(diff, 'year');
+  },
+  addMonth: function addMonth(date, diff) {
+    return date.add(diff, 'month');
+  },
+  addDate: function addDate(date, diff) {
+    return date.add(diff, 'day');
+  },
+  setYear: function setYear(date, year) {
+    return date.year(year);
+  },
+  setMonth: function setMonth(date, month) {
+    return date.month(month);
+  },
+  setDate: function setDate(date, num) {
+    return date.date(num);
+  },
+  setHour: function setHour(date, hour) {
+    return date.hour(hour);
+  },
+  setMinute: function setMinute(date, minute) {
+    return date.minute(minute);
+  },
+  setSecond: function setSecond(date, second) {
+    return date.second(second);
+  },
+  // Compare
+  isAfter: function isAfter(date1, date2) {
+    return date1.isAfter(date2);
+  },
+  isValidate: function isValidate(date) {
+    return date.isValid();
+  },
+  locale: {
+    getWeekFirstDay: function getWeekFirstDay(locale) {
+      return dayjs().locale(parseLocale(locale)).localeData().firstDayOfWeek();
+    },
+    getWeek: function getWeek(locale, date) {
+      return date.locale(parseLocale(locale)).week();
+    },
+    getShortWeekDays: function getShortWeekDays(locale) {
+      return dayjs().locale(parseLocale(locale)).localeData().weekdaysMin();
+    },
+    getShortMonths: function getShortMonths(locale) {
+      return dayjs().locale(parseLocale(locale)).localeData().monthsShort();
+    },
+    format: function format(locale, date, _format) {
+      return date.locale(parseLocale(locale)).format(_format);
+    },
+    parse: function parse(locale, text, formats) {
+      var localeStr = parseLocale(locale);
+
+      for (var i = 0; i < formats.length; i += 1) {
+        var format = formats[i];
+        var formatText = text;
+
+        if (format.includes('wo') || format.includes('Wo')) {
+          // parse Wo
+          var year = formatText.split('-')[0];
+          var weekStr = formatText.split('-')[1];
+          var firstWeek = dayjs(year, 'YYYY').startOf('year').locale(localeStr);
+
+          for (var j = 0; j <= 52; j += 1) {
+            var nextWeek = firstWeek.add(j, 'week');
+
+            if (nextWeek.format('Wo') === weekStr) {
+              return nextWeek;
+            }
+          }
+
+          parseNoMatchNotice();
+          return null;
+        }
+
+        var date = dayjs(formatText, format).locale(localeStr);
+
+        if (date.isValid()) {
+          return date;
+        }
+      }
+
+      parseNoMatchNotice();
+      return null;
+    }
+  }
+};
+export default generateConfig;

web/node_modules/rc-picker/es/generate/index.d.ts

@@ -0,0 +1,32 @@
+export interface GenerateConfig<DateType> {
+    getWeekDay: (value: DateType) => number;
+    getSecond: (value: DateType) => number;
+    getMinute: (value: DateType) => number;
+    getHour: (value: DateType) => number;
+    getDate: (value: DateType) => number;
+    getMonth: (value: DateType) => number;
+    getYear: (value: DateType) => number;
+    getNow: () => DateType;
+    addYear: (value: DateType, diff: number) => DateType;
+    addMonth: (value: DateType, diff: number) => DateType;
+    addDate: (value: DateType, diff: number) => DateType;
+    setYear: (value: DateType, year: number) => DateType;
+    setMonth: (value: DateType, month: number) => DateType;
+    setDate: (value: DateType, date: number) => DateType;
+    setHour: (value: DateType, hour: number) => DateType;
+    setMinute: (value: DateType, minute: number) => DateType;
+    setSecond: (value: DateType, second: number) => DateType;
+    isAfter: (date1: DateType, date2: DateType) => boolean;
+    isValidate: (date: DateType) => boolean;
+    locale: {
+        getWeekFirstDay: (locale: string) => number;
+        getWeek: (locale: string, value: DateType) => number;
+        format: (locale: string, date: DateType, format: string) => string;
+        /** Should only return validate date instance */
+        parse: (locale: string, text: string, formats: string[]) => DateType | null;
+        /** A proxy for getting locale with moment or other locale library */
+        getShortWeekDays?: (locale: string) => string[];
+        /** A proxy for getting locale with moment or other locale library */
+        getShortMonths?: (locale: string) => string[];
+    };
+}

web/node_modules/rc-picker/es/generate/moment.d.ts

@@ -0,0 +1,4 @@
+import { Moment } from 'moment';
+import { GenerateConfig } from '.';
+declare const generateConfig: GenerateConfig<Moment>;
+export default generateConfig;

web/node_modules/rc-picker/es/generate/moment.js

@@ -0,0 +1,140 @@
+import moment from 'moment';
+import { noteOnce } from "rc-util/es/warning";
+var generateConfig = {
+  // get
+  getNow: function getNow() {
+    return moment();
+  },
+  getWeekDay: function getWeekDay(date) {
+    var clone = date.clone().locale('en_US');
+    return clone.weekday() + clone.localeData().firstDayOfWeek();
+  },
+  getYear: function getYear(date) {
+    return date.year();
+  },
+  getMonth: function getMonth(date) {
+    return date.month();
+  },
+  getDate: function getDate(date) {
+    return date.date();
+  },
+  getHour: function getHour(date) {
+    return date.hour();
+  },
+  getMinute: function getMinute(date) {
+    return date.minute();
+  },
+  getSecond: function getSecond(date) {
+    return date.second();
+  },
+  // set
+  addYear: function addYear(date, diff) {
+    var clone = date.clone();
+    return clone.add(diff, 'year');
+  },
+  addMonth: function addMonth(date, diff) {
+    var clone = date.clone();
+    return clone.add(diff, 'month');
+  },
+  addDate: function addDate(date, diff) {
+    var clone = date.clone();
+    return clone.add(diff, 'day');
+  },
+  setYear: function setYear(date, year) {
+    var clone = date.clone();
+    return clone.year(year);
+  },
+  setMonth: function setMonth(date, month) {
+    var clone = date.clone();
+    return clone.month(month);
+  },
+  setDate: function setDate(date, num) {
+    var clone = date.clone();
+    return clone.date(num);
+  },
+  setHour: function setHour(date, hour) {
+    var clone = date.clone();
+    return clone.hour(hour);
+  },
+  setMinute: function setMinute(date, minute) {
+    var clone = date.clone();
+    return clone.minute(minute);
+  },
+  setSecond: function setSecond(date, second) {
+    var clone = date.clone();
+    return clone.second(second);
+  },
+  // Compare
+  isAfter: function isAfter(date1, date2) {
+    return date1.isAfter(date2);
+  },
+  isValidate: function isValidate(date) {
+    return date.isValid();
+  },
+  locale: {
+    getWeekFirstDay: function getWeekFirstDay(locale) {
+      var date = moment().locale(locale);
+      return date.localeData().firstDayOfWeek();
+    },
+    getWeek: function getWeek(locale, date) {
+      var clone = date.clone();
+      var result = clone.locale(locale);
+      return result.week();
+    },
+    getShortWeekDays: function getShortWeekDays(locale) {
+      var date = moment().locale(locale);
+      return date.localeData().weekdaysMin();
+    },
+    getShortMonths: function getShortMonths(locale) {
+      var date = moment().locale(locale);
+      return date.localeData().monthsShort();
+    },
+    format: function format(locale, date, _format) {
+      var clone = date.clone();
+      var result = clone.locale(locale);
+      return result.format(_format);
+    },
+    parse: function parse(locale, text, formats) {
+      var fallbackFormatList = [];
+
+      for (var i = 0; i < formats.length; i += 1) {
+        var format = formats[i];
+        var formatText = text;
+
+        if (format.includes('wo') || format.includes('Wo')) {
+          format = format.replace(/wo/g, 'w').replace(/Wo/g, 'W');
+          var matchFormat = format.match(/[-YyMmDdHhSsWwGg]+/g);
+          var matchText = formatText.match(/[-\d]+/g);
+
+          if (matchFormat && matchText) {
+            format = matchFormat.join('');
+            formatText = matchText.join('');
+          } else {
+            fallbackFormatList.push(format.replace(/o/g, ''));
+          }
+        }
+
+        var date = moment(formatText, format, locale, true);
+
+        if (date.isValid()) {
+          return date;
+        }
+      } // Fallback to fuzzy matching, this should always not reach match or need fire a issue
+
+
+      for (var _i = 0; _i < fallbackFormatList.length; _i += 1) {
+        var _date = moment(text, fallbackFormatList[_i], locale, false);
+        /* istanbul ignore next */
+
+
+        if (_date.isValid()) {
+          noteOnce(false, 'Not match any format strictly and fallback to fuzzy match. Please help to fire a issue about this.');
+          return _date;
+        }
+      }
+
+      return null;
+    }
+  }
+};
+export default generateConfig;

web/node_modules/rc-picker/es/hooks/useCellClassName.d.ts

@@ -0,0 +1,15 @@
+import { GenerateConfig } from '../generate';
+import { RangeValue, NullableDateType } from '../interface';
+export default function useCellClassName<DateType>({ cellPrefixCls, generateConfig, rangedValue, hoverRangedValue, isInView, isSameCell, offsetCell, today, value, }: {
+    cellPrefixCls: string;
+    generateConfig: GenerateConfig<DateType>;
+    isSameCell: (current: NullableDateType<DateType>, target: NullableDateType<DateType>) => boolean;
+    offsetCell: (date: DateType, offset: number) => DateType;
+    isInView: (date: DateType) => boolean;
+    rangedValue?: RangeValue<DateType>;
+    hoverRangedValue?: RangeValue<DateType>;
+    today?: NullableDateType<DateType>;
+    value?: NullableDateType<DateType>;
+}): (currentDate: DateType) => {
+    [x: string]: boolean;
+};

web/node_modules/rc-picker/es/hooks/useCellClassName.js

@@ -0,0 +1,43 @@
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import { isInRange } from '../utils/dateUtil';
+import { getValue } from '../utils/miscUtil';
+export default function useCellClassName(_ref) {
+  var cellPrefixCls = _ref.cellPrefixCls,
+      generateConfig = _ref.generateConfig,
+      rangedValue = _ref.rangedValue,
+      hoverRangedValue = _ref.hoverRangedValue,
+      isInView = _ref.isInView,
+      isSameCell = _ref.isSameCell,
+      offsetCell = _ref.offsetCell,
+      today = _ref.today,
+      value = _ref.value;
+
+  function getClassName(currentDate) {
+    var _ref2;
+
+    var prevDate = offsetCell(currentDate, -1);
+    var nextDate = offsetCell(currentDate, 1);
+    var rangeStart = getValue(rangedValue, 0);
+    var rangeEnd = getValue(rangedValue, 1);
+    var hoverStart = getValue(hoverRangedValue, 0);
+    var hoverEnd = getValue(hoverRangedValue, 1);
+    var isRangeHovered = isInRange(generateConfig, hoverStart, hoverEnd, currentDate);
+
+    function isRangeStart(date) {
+      return isSameCell(rangeStart, date);
+    }
+
+    function isRangeEnd(date) {
+      return isSameCell(rangeEnd, date);
+    }
+
+    var isHoverStart = isSameCell(hoverStart, currentDate);
+    var isHoverEnd = isSameCell(hoverEnd, currentDate);
+    var isHoverEdgeStart = (isRangeHovered || isHoverEnd) && (!isInView(prevDate) || isRangeEnd(prevDate));
+    var isHoverEdgeEnd = (isRangeHovered || isHoverStart) && (!isInView(nextDate) || isRangeStart(nextDate));
+    return _ref2 = {}, _defineProperty(_ref2, "".concat(cellPrefixCls, "-in-view"), isInView(currentDate)), _defineProperty(_ref2, "".concat(cellPrefixCls, "-in-range"), isInRange(generateConfig, rangeStart, rangeEnd, currentDate)), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-start"), isRangeStart(currentDate)), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-end"), isRangeEnd(currentDate)), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-start-single"), isRangeStart(currentDate) && !rangeEnd), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-end-single"), isRangeEnd(currentDate) && !rangeStart), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-start-near-hover"), isRangeStart(currentDate) && (isSameCell(prevDate, hoverStart) || isInRange(generateConfig, hoverStart, hoverEnd, prevDate))), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-end-near-hover"), isRangeEnd(currentDate) && (isSameCell(nextDate, hoverEnd) || isInRange(generateConfig, hoverStart, hoverEnd, nextDate))), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-hover"), isRangeHovered), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-hover-start"), isHoverStart), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-hover-end"), isHoverEnd), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-start"), isHoverEdgeStart), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-end"), isHoverEdgeEnd), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-start-near-range"), isHoverEdgeStart && isSameCell(prevDate, rangeEnd)), _defineProperty(_ref2, "".concat(cellPrefixCls, "-range-hover-edge-end-near-range"), isHoverEdgeEnd && isSameCell(nextDate, rangeStart)), _defineProperty(_ref2, "".concat(cellPrefixCls, "-today"), isSameCell(today, currentDate)), _defineProperty(_ref2, "".concat(cellPrefixCls, "-selected"), isSameCell(value, currentDate)), _ref2;
+  }
+
+  return getClassName;
+}

web/node_modules/rc-picker/es/hooks/usePickerInput.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+export default function usePickerInput({ open, isClickOutside, triggerOpen, forwardKeyDown, blurToCancel, onSubmit, onCancel, onFocus, onBlur, }: {
+    open: boolean;
+    isClickOutside: (clickElement: EventTarget | null) => boolean;
+    triggerOpen: (open: boolean) => void;
+    forwardKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => boolean;
+    blurToCancel?: boolean;
+    onSubmit: () => void | boolean;
+    onCancel: () => void;
+    onFocus?: React.FocusEventHandler<HTMLInputElement>;
+    onBlur?: React.FocusEventHandler<HTMLInputElement>;
+}): [React.DOMAttributes<HTMLInputElement>, {
+    focused: boolean;
+    typing: boolean;
+}];

web/node_modules/rc-picker/es/hooks/usePickerInput.js

@@ -0,0 +1,145 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+import KeyCode from "rc-util/es/KeyCode";
+import { addGlobalMouseDownEvent } from '../utils/uiUtil';
+export default function usePickerInput(_ref) {
+  var open = _ref.open,
+      isClickOutside = _ref.isClickOutside,
+      triggerOpen = _ref.triggerOpen,
+      forwardKeyDown = _ref.forwardKeyDown,
+      blurToCancel = _ref.blurToCancel,
+      onSubmit = _ref.onSubmit,
+      onCancel = _ref.onCancel,
+      _onFocus = _ref.onFocus,
+      _onBlur = _ref.onBlur;
+
+  var _React$useState = React.useState(false),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      typing = _React$useState2[0],
+      setTyping = _React$useState2[1];
+
+  var _React$useState3 = React.useState(false),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      focused = _React$useState4[0],
+      setFocused = _React$useState4[1];
+  /**
+   * We will prevent blur to handle open event when user click outside,
+   * since this will repeat trigger `onOpenChange` event.
+   */
+
+
+  var preventBlurRef = React.useRef(false);
+  var inputProps = {
+    onMouseDown: function onMouseDown() {
+      setTyping(true);
+      triggerOpen(true);
+    },
+    onKeyDown: function onKeyDown(e) {
+      switch (e.which) {
+        case KeyCode.ENTER:
+          {
+            if (!open) {
+              triggerOpen(true);
+            } else if (onSubmit() !== false) {
+              setTyping(true);
+            }
+
+            e.preventDefault();
+            return;
+          }
+
+        case KeyCode.TAB:
+          {
+            if (typing && open && !e.shiftKey) {
+              setTyping(false);
+              e.preventDefault();
+            } else if (!typing && open) {
+              if (!forwardKeyDown(e) && e.shiftKey) {
+                setTyping(true);
+                e.preventDefault();
+              }
+            }
+
+            return;
+          }
+
+        case KeyCode.ESC:
+          {
+            setTyping(true);
+            onCancel();
+            return;
+          }
+      }
+
+      if (!open && ![KeyCode.SHIFT].includes(e.which)) {
+        triggerOpen(true);
+      } else if (!typing) {
+        // Let popup panel handle keyboard
+        forwardKeyDown(e);
+      }
+    },
+    onFocus: function onFocus(e) {
+      setTyping(true);
+      setFocused(true);
+
+      if (_onFocus) {
+        _onFocus(e);
+      }
+    },
+    onBlur: function onBlur(e) {
+      if (preventBlurRef.current || !isClickOutside(document.activeElement)) {
+        preventBlurRef.current = false;
+        return;
+      }
+
+      if (blurToCancel) {
+        setTimeout(function () {
+          if (isClickOutside(document.activeElement)) {
+            onCancel();
+          }
+        }, 0);
+      } else {
+        triggerOpen(false);
+      }
+
+      setFocused(false);
+
+      if (_onBlur) {
+        _onBlur(e);
+      }
+    }
+  }; // Global click handler
+
+  React.useEffect(function () {
+    return addGlobalMouseDownEvent(function (_ref2) {
+      var target = _ref2.target;
+
+      if (open) {
+        if (!isClickOutside(target)) {
+          preventBlurRef.current = true; // Always set back in case `onBlur` prevented by user
+
+          window.setTimeout(function () {
+            preventBlurRef.current = false;
+          }, 0);
+        } else if (!focused) {
+          triggerOpen(false);
+        }
+      }
+    });
+  });
+  return [inputProps, {
+    focused: focused,
+    typing: typing
+  }];
+}

web/node_modules/rc-picker/es/hooks/useRangeDisabled.d.ts

@@ -0,0 +1,10 @@
+import { RangeValue, PickerMode, Locale } from '../interface';
+import { GenerateConfig } from '../generate';
+export default function useRangeDisabled<DateType>({ picker, locale, selectedValue, disabledDate, disabled, generateConfig, }: {
+    picker: PickerMode;
+    selectedValue: RangeValue<DateType>;
+    disabledDate?: (date: DateType) => boolean;
+    disabled: [boolean, boolean];
+    locale: Locale;
+    generateConfig: GenerateConfig<DateType>;
+}): ((date: DateType) => boolean)[];

web/node_modules/rc-picker/es/hooks/useRangeDisabled.js

@@ -0,0 +1,78 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+import { getValue } from '../utils/miscUtil';
+import { isSameDate } from '../utils/dateUtil';
+import useWeekDisabled from './useWeekDisabled';
+export default function useRangeDisabled(_ref) {
+  var picker = _ref.picker,
+      locale = _ref.locale,
+      selectedValue = _ref.selectedValue,
+      disabledDate = _ref.disabledDate,
+      disabled = _ref.disabled,
+      generateConfig = _ref.generateConfig;
+  var startDate = getValue(selectedValue, 0);
+  var endDate = getValue(selectedValue, 1);
+  var disabledStartDate = React.useCallback(function (date) {
+    if (disabledDate && disabledDate(date)) {
+      return true;
+    }
+
+    if (disabled[1] && endDate) {
+      return !isSameDate(generateConfig, date, endDate) && generateConfig.isAfter(date, endDate);
+    }
+
+    return false;
+  }, [disabledDate, disabled[1], endDate]);
+  var disableEndDate = React.useCallback(function (date) {
+    if (disabledDate && disabledDate(date)) {
+      return true;
+    }
+
+    if (startDate) {
+      var compareStartDate = picker === 'week' ? generateConfig.addDate(startDate, -7) : startDate;
+      return !isSameDate(generateConfig, date, compareStartDate) && generateConfig.isAfter(compareStartDate, date);
+    }
+
+    return false;
+  }, [disabledDate, startDate, picker]); // Handle week date disabled
+
+  var sharedWeekDisabledConfig = {
+    generateConfig: generateConfig,
+    locale: locale
+  };
+
+  var _useWeekDisabled = useWeekDisabled(_objectSpread({}, sharedWeekDisabledConfig, {
+    disabledDate: disabledStartDate
+  })),
+      _useWeekDisabled2 = _slicedToArray(_useWeekDisabled, 1),
+      disabledStartWeekDate = _useWeekDisabled2[0];
+
+  var _useWeekDisabled3 = useWeekDisabled(_objectSpread({}, sharedWeekDisabledConfig, {
+    disabledDate: disableEndDate
+  })),
+      _useWeekDisabled4 = _slicedToArray(_useWeekDisabled3, 1),
+      disabledEndWeekDate = _useWeekDisabled4[0];
+
+  if (picker === 'week') {
+    return [disabledStartWeekDate, disabledEndWeekDate];
+  }
+
+  return [disabledStartDate, disableEndDate];
+}

web/node_modules/rc-picker/es/hooks/useRangeViewDates.d.ts

@@ -0,0 +1,8 @@
+import { RangeValue, PickerMode } from '../interface';
+import { GenerateConfig } from '../generate';
+export default function useRangeViewDates<DateType>({ values, picker, defaultDates, generateConfig, }: {
+    values: RangeValue<DateType>;
+    picker: PickerMode;
+    defaultDates: RangeValue<DateType> | undefined;
+    generateConfig: GenerateConfig<DateType>;
+}): [(activePickerIndex: 0 | 1) => DateType, (viewDate: DateType | null, index: 0 | 1) => void];

web/node_modules/rc-picker/es/hooks/useRangeViewDates.js

@@ -0,0 +1,127 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+import { getValue, updateValues } from '../utils/miscUtil';
+import { getClosingViewDate, isSameYear, isSameMonth, isSameDecade } from '../utils/dateUtil';
+
+function getStartEndDistance(startDate, endDate, picker, generateConfig) {
+  var startNext = getClosingViewDate(startDate, picker, generateConfig, 1);
+
+  function getDistance(compareFunc) {
+    if (compareFunc(startDate, endDate)) {
+      return 'same';
+    }
+
+    if (compareFunc(startNext, endDate)) {
+      return 'closing';
+    }
+
+    return 'far';
+  }
+
+  switch (picker) {
+    case 'year':
+      return getDistance(function (start, end) {
+        return isSameDecade(generateConfig, start, end);
+      });
+
+    case 'month':
+      return getDistance(function (start, end) {
+        return isSameYear(generateConfig, start, end);
+      });
+
+    default:
+      return getDistance(function (start, end) {
+        return isSameMonth(generateConfig, start, end);
+      });
+  }
+}
+
+function getRangeViewDate(values, index, picker, generateConfig) {
+  var startDate = getValue(values, 0);
+  var endDate = getValue(values, 1);
+
+  if (index === 0) {
+    return startDate;
+  }
+
+  if (startDate && endDate) {
+    var distance = getStartEndDistance(startDate, endDate, picker, generateConfig);
+
+    switch (distance) {
+      case 'same':
+        return startDate;
+
+      case 'closing':
+        return startDate;
+
+      default:
+        return getClosingViewDate(endDate, picker, generateConfig, -1);
+    }
+  }
+
+  return startDate;
+}
+
+export default function useRangeViewDates(_ref) {
+  var values = _ref.values,
+      picker = _ref.picker,
+      defaultDates = _ref.defaultDates,
+      generateConfig = _ref.generateConfig;
+
+  var _React$useState = React.useState(function () {
+    return [getValue(defaultDates, 0), getValue(defaultDates, 1)];
+  }),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      defaultViewDates = _React$useState2[0],
+      setDefaultViewDates = _React$useState2[1];
+
+  var _React$useState3 = React.useState(null),
+      _React$useState4 = _slicedToArray(_React$useState3, 2),
+      viewDates = _React$useState4[0],
+      setInternalViewDates = _React$useState4[1];
+
+  var startDate = getValue(values, 0);
+  var endDate = getValue(values, 1);
+
+  function getViewDate(index) {
+    // If set default view date, use it
+    if (defaultViewDates[index]) {
+      return defaultViewDates[index];
+    }
+
+    return getValue(viewDates, index) || getRangeViewDate(values, index, picker, generateConfig) || startDate || endDate || generateConfig.getNow();
+  }
+
+  function setViewDate(viewDate, index) {
+    if (viewDate) {
+      var newViewDates = updateValues(viewDates, viewDate, index); // Set view date will clean up default one
+
+      setDefaultViewDates( // Should always be an array
+      updateValues(defaultViewDates, null, index) || [null, null]); // Reset another one when not have value
+
+      var anotherIndex = (index + 1) % 2;
+
+      if (getValue(values, anotherIndex)) {
+        newViewDates = updateValues(newViewDates, viewDate, anotherIndex);
+      }
+
+      setInternalViewDates(newViewDates);
+    } else if (startDate || endDate) {
+      // Reset all when has values when `viewDate` is `null` which means from open trigger
+      setInternalViewDates(null);
+    }
+  }
+
+  return [getViewDate, setViewDate];
+}

web/node_modules/rc-picker/es/hooks/useTextValueMapping.d.ts

@@ -0,0 +1,5 @@
+export default function useTextValueMapping<ValueType>({ valueTexts, onTextChange, }: {
+    /** Must useMemo, to assume that `valueTexts` only match on the first change */
+    valueTexts: string[];
+    onTextChange: (text: string) => void;
+}): [string, (text: string) => void, () => void];

web/node_modules/rc-picker/es/hooks/useTextValueMapping.js

@@ -0,0 +1,43 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import * as React from 'react';
+export default function useTextValueMapping(_ref) {
+  var valueTexts = _ref.valueTexts,
+      onTextChange = _ref.onTextChange;
+
+  var _React$useState = React.useState(''),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      text = _React$useState2[0],
+      setInnerText = _React$useState2[1];
+
+  var valueTextsRef = React.useRef([]);
+  valueTextsRef.current = valueTexts;
+
+  function triggerTextChange(value) {
+    setInnerText(value);
+    onTextChange(value);
+  }
+
+  function resetText() {
+    setInnerText(valueTextsRef.current[0]);
+  }
+
+  React.useEffect(function () {
+    if (valueTexts.every(function (valText) {
+      return valText !== text;
+    })) {
+      resetText();
+    }
+  }, [valueTexts.join('||')]);
+  return [text, triggerTextChange, resetText];
+}

web/node_modules/rc-picker/es/hooks/useValueTexts.d.ts

@@ -0,0 +1,9 @@
+import { GenerateConfig } from '../generate';
+import { Locale } from '../interface';
+interface ValueTextConfig<DateType> {
+    formatList: string[];
+    generateConfig: GenerateConfig<DateType>;
+    locale: Locale;
+}
+export default function useValueTexts<DateType>(value: DateType | null, { formatList, generateConfig, locale }: ValueTextConfig<DateType>): string[];
+export {};

web/node_modules/rc-picker/es/hooks/useValueTexts.js

@@ -0,0 +1,18 @@
+import shallowEqual from 'shallowequal';
+import useMemo from "rc-util/es/hooks/useMemo";
+export default function useValueTexts(value, _ref) {
+  var formatList = _ref.formatList,
+      generateConfig = _ref.generateConfig,
+      locale = _ref.locale;
+  return useMemo(function () {
+    if (!value) {
+      return [''];
+    }
+
+    return formatList.map(function (subFormat) {
+      return generateConfig.locale.format(locale.locale, value, subFormat);
+    });
+  }, [value, formatList], function (prev, next) {
+    return prev[0] !== next[0] || !shallowEqual(prev[1], next[1]);
+  });
+}

web/node_modules/rc-picker/es/hooks/useWeekDisabled.d.ts

@@ -0,0 +1,7 @@
+import { GenerateConfig } from '../generate';
+import { Locale } from '../interface';
+export default function useWeekDisabled<DateType>({ disabledDate, locale, generateConfig, }: {
+    disabledDate: (date: DateType) => boolean;
+    locale: Locale;
+    generateConfig: GenerateConfig<DateType>;
+}): [(date: DateType) => boolean];

web/node_modules/rc-picker/es/hooks/useWeekDisabled.js

@@ -0,0 +1,41 @@
+import * as React from 'react';
+export default function useWeekDisabled(_ref) {
+  var disabledDate = _ref.disabledDate,
+      locale = _ref.locale,
+      generateConfig = _ref.generateConfig;
+  var disabledCache = React.useMemo(function () {
+    return new Map();
+  }, [disabledDate]);
+
+  function disabledWeekDate(date) {
+    var weekStr = generateConfig.locale.format(locale.locale, date, 'YYYY-WW');
+
+    if (!disabledCache.has(weekStr)) {
+      var disabled = false;
+
+      var checkDisabled = function checkDisabled(offset) {
+        for (var i = 0; i < 7; i += 1) {
+          var currentDate = generateConfig.addDate(date, i * offset);
+          var currentWeekStr = generateConfig.locale.format(locale.locale, currentDate, 'YYYY-WW');
+
+          if (currentWeekStr !== weekStr) {
+            break;
+          }
+
+          if (disabledDate(currentDate)) {
+            disabled = true;
+            break;
+          }
+        }
+      };
+
+      checkDisabled(1);
+      checkDisabled(-1);
+      disabledCache.set(weekStr, disabled);
+    }
+
+    return disabledCache.get(weekStr);
+  }
+
+  return [disabledWeekDate];
+}

web/node_modules/rc-picker/es/index.d.ts

@@ -0,0 +1,5 @@
+import Picker, { PickerProps } from './Picker';
+import PickerPanel, { PickerPanelProps } from './PickerPanel';
+import RangePicker, { RangePickerProps } from './RangePicker';
+export { PickerPanel, RangePicker, PickerProps, PickerPanelProps, RangePickerProps, };
+export default Picker;

web/node_modules/rc-picker/es/index.js

@@ -0,0 +1,5 @@
+import Picker from './Picker';
+import PickerPanel from './PickerPanel';
+import RangePicker from './RangePicker';
+export { PickerPanel, RangePicker };
+export default Picker;

web/node_modules/rc-picker/es/interface.d.ts

@@ -0,0 +1,87 @@
+/// <reference types="react" />
+import { GenerateConfig } from './generate';
+export interface Locale {
+    locale: string;
+    /** Display month before year in date panel header */
+    monthBeforeYear?: boolean;
+    yearFormat: string;
+    monthFormat?: string;
+    quarterFormat?: string;
+    today: string;
+    now: string;
+    backToToday: string;
+    ok: string;
+    timeSelect: string;
+    dateSelect: string;
+    weekSelect?: string;
+    clear: string;
+    month: string;
+    year: string;
+    previousMonth: string;
+    nextMonth: string;
+    monthSelect: string;
+    yearSelect: string;
+    decadeSelect: string;
+    dayFormat: string;
+    dateFormat: string;
+    dateTimeFormat: string;
+    previousYear: string;
+    nextYear: string;
+    previousDecade: string;
+    nextDecade: string;
+    previousCentury: string;
+    nextCentury: string;
+    shortWeekDays?: string[];
+    shortMonths?: string[];
+}
+export declare type PanelMode = 'time' | 'date' | 'week' | 'month' | 'quarter' | 'year' | 'decade';
+export declare type PickerMode = Exclude<PanelMode, 'datetime' | 'decade'>;
+export interface PanelRefProps {
+    onKeyDown?: (e: React.KeyboardEvent<HTMLElement>) => boolean;
+    onBlur?: React.FocusEventHandler<HTMLElement>;
+    onClose?: () => void;
+}
+export declare type NullableDateType<DateType> = DateType | null | undefined;
+export declare type OnSelect<DateType> = (value: DateType, type: 'key' | 'mouse' | 'submit') => void;
+export interface PanelSharedProps<DateType> {
+    prefixCls: string;
+    generateConfig: GenerateConfig<DateType>;
+    value?: NullableDateType<DateType>;
+    viewDate: DateType;
+    /** [Legacy] Set default display picker view date */
+    defaultPickerValue?: DateType;
+    locale: Locale;
+    disabledDate?: (date: DateType) => boolean;
+    prevIcon?: React.ReactNode;
+    nextIcon?: React.ReactNode;
+    superPrevIcon?: React.ReactNode;
+    superNextIcon?: React.ReactNode;
+    /**
+     * Typescript can not handle generic type so we can not use `forwardRef` here.
+     * Thus, move ref into operationRef.
+     * This is little hack which should refactor after typescript support.
+     */
+    operationRef: React.MutableRefObject<PanelRefProps>;
+    onSelect: OnSelect<DateType>;
+    onViewDateChange: (value: DateType) => void;
+    onPanelChange: (mode: PanelMode | null, viewValue: DateType) => void;
+}
+export interface DisabledTimes {
+    disabledHours?: () => number[];
+    disabledMinutes?: (hour: number) => number[];
+    disabledSeconds?: (hour: number, minute: number) => number[];
+}
+export declare type DisabledTime<DateType> = (date: DateType | null) => DisabledTimes;
+export declare type OnPanelChange<DateType> = (value: DateType, mode: PanelMode) => void;
+export declare type EventValue<DateType> = DateType | null;
+export declare type RangeValue<DateType> = [EventValue<DateType>, EventValue<DateType>] | null;
+export interface Components {
+    button?: React.ComponentType | string;
+    rangeItem?: React.ComponentType | string;
+}
+export declare type RangeList = {
+    label: string;
+    onClick: () => void;
+    onMouseEnter: () => void;
+    onMouseLeave: () => void;
+}[];

web/node_modules/rc-picker/es/locale/ar_EG.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/ar_EG.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'ar_EG',
+  today: 'اليوم',
+  now: 'الأن',
+  backToToday: 'العودة إلى اليوم',
+  ok: 'تأكيد',
+  clear: 'مسح',
+  month: 'الشهر',
+  year: 'السنة',
+  timeSelect: 'اختيار الوقت',
+  dateSelect: 'اختيار التاريخ',
+  monthSelect: 'اختيار الشهر',
+  yearSelect: 'اختيار السنة',
+  decadeSelect: 'اختيار العقد',
+  yearFormat: 'YYYY',
+  dateFormat: 'M/D/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'الشهر السابق (PageUp)',
+  nextMonth: 'الشهر التالى(PageDown)',
+  previousYear: 'العام السابق (Control + left)',
+  nextYear: 'العام التالى (Control + right)',
+  previousDecade: 'العقد السابق',
+  nextDecade: 'العقد التالى',
+  previousCentury: 'القرن السابق',
+  nextCentury: 'القرن التالى'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/az_AZ.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/az_AZ.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'az_AZ',
+  today: 'Bugün',
+  now: 'İndi',
+  backToToday: 'Bugünə qayıt',
+  ok: 'Təsdiq',
+  clear: 'Təmizlə',
+  month: 'Ay',
+  year: 'İl',
+  timeSelect: 'vaxtı seç',
+  dateSelect: 'tarixi seç',
+  weekSelect: 'Həftə seç',
+  monthSelect: 'Ay seç',
+  yearSelect: 'il seç',
+  decadeSelect: 'Onillik seçin',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Əvvəlki ay (PageUp)',
+  nextMonth: 'Növbəti ay (PageDown)',
+  previousYear: 'Sonuncu il (Control + left)',
+  nextYear: 'Növbəti il (Control + right)',
+  previousDecade: 'Sonuncu onillik',
+  nextDecade: 'Növbəti onillik',
+  previousCentury: 'Sonuncu əsr',
+  nextCentury: 'Növbəti əsr'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/bg_BG.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/bg_BG.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'bg_BG',
+  today: 'Днес',
+  now: 'Сега',
+  backToToday: 'Към днес',
+  ok: 'Добре',
+  clear: 'Изчистване',
+  month: 'Месец',
+  year: 'Година',
+  timeSelect: 'Избор на час',
+  dateSelect: 'Избор на дата',
+  monthSelect: 'Избор на месец',
+  yearSelect: 'Избор на година',
+  decadeSelect: 'Десетилетие',
+  yearFormat: 'YYYY',
+  dateFormat: 'D M YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D M YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Предишен месец (PageUp)',
+  nextMonth: 'Следващ месец (PageDown)',
+  previousYear: 'Последна година (Control + left)',
+  nextYear: 'Следваща година (Control + right)',
+  previousDecade: 'Предишно десетилетие',
+  nextDecade: 'Следващо десетилетие',
+  previousCentury: 'Последен век',
+  nextCentury: 'Следващ век'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/ca_ES.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/ca_ES.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'ca_ES',
+  today: 'Avui',
+  now: 'Ara',
+  backToToday: 'Tornar a avui',
+  ok: 'Acceptar',
+  clear: 'Netejar',
+  month: 'Mes',
+  year: 'Any',
+  timeSelect: 'Seleccionar hora',
+  dateSelect: 'Seleccionar data',
+  monthSelect: 'Escollir un mes',
+  yearSelect: 'Escollir un any',
+  decadeSelect: 'Escollir una dècada',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Mes anterior (PageUp)',
+  nextMonth: 'Mes següent (PageDown)',
+  previousYear: 'Any anterior (Control + left)',
+  nextYear: 'Mes següent (Control + right)',
+  previousDecade: 'Dècada anterior',
+  nextDecade: 'Dècada següent',
+  previousCentury: 'Segle anterior',
+  nextCentury: 'Segle següent'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/cs_CZ.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/cs_CZ.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'cs_CZ',
+  today: 'Dnes',
+  now: 'Nyní',
+  backToToday: 'Zpět na dnešek',
+  ok: 'Ok',
+  clear: 'Vymazat',
+  month: 'Měsíc',
+  year: 'Rok',
+  timeSelect: 'Vybrat čas',
+  dateSelect: 'Vybrat datum',
+  monthSelect: 'Vyberte měsíc',
+  yearSelect: 'Vyberte rok',
+  decadeSelect: 'Vyberte dekádu',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Předchozí měsíc (PageUp)',
+  nextMonth: 'Následující (PageDown)',
+  previousYear: 'Předchozí rok (Control + left)',
+  nextYear: 'Následující rok (Control + right)',
+  previousDecade: 'Předchozí dekáda',
+  nextDecade: 'Následující dekáda',
+  previousCentury: 'Předchozí století',
+  nextCentury: 'Následující století'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/da_DK.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/da_DK.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'da_DK',
+  today: 'I dag',
+  now: 'Nu',
+  backToToday: 'Gå til i dag',
+  ok: 'Ok',
+  clear: 'Ryd',
+  month: 'Måned',
+  year: 'År',
+  timeSelect: 'Vælg tidspunkt',
+  dateSelect: 'Vælg dato',
+  monthSelect: 'Vælg måned',
+  yearSelect: 'Vælg år',
+  decadeSelect: 'Vælg årti',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Forrige måned (Page Up)',
+  nextMonth: 'Næste måned (Page Down)',
+  previousYear: 'Forrige år (Ctrl-venstre pil)',
+  nextYear: 'Næste år (Ctrl-højre pil)',
+  previousDecade: 'Forrige årti',
+  nextDecade: 'Næste årti',
+  previousCentury: 'Forrige århundrede',
+  nextCentury: 'Næste århundrede'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/de_DE.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/de_DE.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'de_DE',
+  today: 'Heute',
+  now: 'Jetzt',
+  backToToday: 'Zurück zu Heute',
+  ok: 'OK',
+  clear: 'Zurücksetzen',
+  month: 'Monat',
+  year: 'Jahr',
+  timeSelect: 'Zeit wählen',
+  dateSelect: 'Datum wählen',
+  monthSelect: 'Wähle einen Monat',
+  yearSelect: 'Wähle ein Jahr',
+  decadeSelect: 'Wähle ein Jahrzehnt',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Vorheriger Monat (PageUp)',
+  nextMonth: 'Nächster Monat (PageDown)',
+  previousYear: 'Vorheriges Jahr (Ctrl + left)',
+  nextYear: 'Nächstes Jahr (Ctrl + right)',
+  previousDecade: 'Vorheriges Jahrzehnt',
+  nextDecade: 'Nächstes Jahrzehnt',
+  previousCentury: 'Vorheriges Jahrhundert',
+  nextCentury: 'Nächstes Jahrhundert'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/el_GR.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/el_GR.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'el_GR',
+  today: 'Σήμερα',
+  now: 'Τώρα',
+  backToToday: 'Πίσω στη σημερινή μέρα',
+  ok: 'Ok',
+  clear: 'Καθαρισμός',
+  month: 'Μήνας',
+  year: 'Έτος',
+  timeSelect: 'Επιλογή ώρας',
+  dateSelect: 'Επιλογή ημερομηνίας',
+  monthSelect: 'Επιλογή μήνα',
+  yearSelect: 'Επιλογή έτους',
+  decadeSelect: 'Επιλογή δεκαετίας',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Προηγούμενος μήνας (PageUp)',
+  nextMonth: 'Επόμενος μήνας (PageDown)',
+  previousYear: 'Προηγούμενο έτος (Control + αριστερά)',
+  nextYear: 'Επόμενο έτος (Control + δεξιά)',
+  previousDecade: 'Προηγούμενη δεκαετία',
+  nextDecade: 'Επόμενη δεκαετία',
+  previousCentury: 'Προηγούμενος αιώνας',
+  nextCentury: 'Επόμενος αιώνας'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/en_GB.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/en_GB.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'en_GB',
+  today: 'Today',
+  now: 'Now',
+  backToToday: 'Back to today',
+  ok: 'Ok',
+  clear: 'Clear',
+  month: 'Month',
+  year: 'Year',
+  timeSelect: 'Select time',
+  dateSelect: 'Select date',
+  monthSelect: 'Choose a month',
+  yearSelect: 'Choose a year',
+  decadeSelect: 'Choose a decade',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Previous month (PageUp)',
+  nextMonth: 'Next month (PageDown)',
+  previousYear: 'Last year (Control + left)',
+  nextYear: 'Next year (Control + right)',
+  previousDecade: 'Last decade',
+  nextDecade: 'Next decade',
+  previousCentury: 'Last century',
+  nextCentury: 'Next century'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/en_US.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/en_US.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'en_US',
+  today: 'Today',
+  now: 'Now',
+  backToToday: 'Back to today',
+  ok: 'Ok',
+  clear: 'Clear',
+  month: 'Month',
+  year: 'Year',
+  timeSelect: 'select time',
+  dateSelect: 'select date',
+  weekSelect: 'Choose a week',
+  monthSelect: 'Choose a month',
+  yearSelect: 'Choose a year',
+  decadeSelect: 'Choose a decade',
+  yearFormat: 'YYYY',
+  dateFormat: 'M/D/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Previous month (PageUp)',
+  nextMonth: 'Next month (PageDown)',
+  previousYear: 'Last year (Control + left)',
+  nextYear: 'Next year (Control + right)',
+  previousDecade: 'Last decade',
+  nextDecade: 'Next decade',
+  previousCentury: 'Last century',
+  nextCentury: 'Next century'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/es_ES.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/es_ES.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'es_ES',
+  today: 'Hoy',
+  now: 'Ahora',
+  backToToday: 'Volver a hoy',
+  ok: 'Aceptar',
+  clear: 'Limpiar',
+  month: 'Mes',
+  year: 'Año',
+  timeSelect: 'Seleccionar hora',
+  dateSelect: 'Seleccionar fecha',
+  monthSelect: 'Elegir un mes',
+  yearSelect: 'Elegir un año',
+  decadeSelect: 'Elegir una década',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Mes anterior (PageUp)',
+  nextMonth: 'Mes siguiente (PageDown)',
+  previousYear: 'Año anterior (Control + left)',
+  nextYear: 'Año siguiente (Control + right)',
+  previousDecade: 'Década anterior',
+  nextDecade: 'Década siguiente',
+  previousCentury: 'Siglo anterior',
+  nextCentury: 'Siglo siguiente'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/et_EE.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/et_EE.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'et_EE',
+  today: 'Täna',
+  now: 'Praegu',
+  backToToday: 'Tagasi tänase juurde',
+  ok: 'Ok',
+  clear: 'Tühista',
+  month: 'Kuu',
+  year: 'Aasta',
+  timeSelect: 'Vali aeg',
+  dateSelect: 'Vali kuupäev',
+  monthSelect: 'Vali kuu',
+  yearSelect: 'Vali aasta',
+  decadeSelect: 'Vali dekaad',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Eelmine kuu (PageUp)',
+  nextMonth: 'Järgmine kuu (PageDown)',
+  previousYear: 'Eelmine aasta (Control + left)',
+  nextYear: 'Järgmine aasta (Control + right)',
+  previousDecade: 'Eelmine dekaad',
+  nextDecade: 'Järgmine dekaad',
+  previousCentury: 'Eelmine sajand',
+  nextCentury: 'Järgmine sajand'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/fa_IR.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/fa_IR.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'fa_IR',
+  today: 'امروز',
+  now: 'اکنون',
+  backToToday: 'بازگشت به روز',
+  ok: 'باشه',
+  clear: 'پاک کردن',
+  month: 'ماه',
+  year: 'سال',
+  timeSelect: 'انتخاب زمان',
+  dateSelect: 'انتخاب تاریخ',
+  monthSelect: 'یک ماه را انتخاب کنید',
+  yearSelect: 'یک سال را انتخاب کنید',
+  decadeSelect: 'یک دهه را انتخاب کنید',
+  yearFormat: 'YYYY',
+  dateFormat: 'M/D/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'ماه قبل (PageUp)',
+  nextMonth: 'ماه بعد (PageDown)',
+  previousYear: 'سال قبل (Control + left)',
+  nextYear: 'سال بعد (Control + right)',
+  previousDecade: 'دهه قبل',
+  nextDecade: 'دهه بعد',
+  previousCentury: 'قرن قبل',
+  nextCentury: 'قرن بعد'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/fi_FI.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/fi_FI.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'fi_FI',
+  today: 'Tänään',
+  now: 'Nyt',
+  backToToday: 'Tämä päivä',
+  ok: 'Ok',
+  clear: 'Tyhjennä',
+  month: 'Kuukausi',
+  year: 'Vuosi',
+  timeSelect: 'Valise aika',
+  dateSelect: 'Valitse päivä',
+  monthSelect: 'Valitse kuukausi',
+  yearSelect: 'Valitse vuosi',
+  decadeSelect: 'Valitse vuosikymmen',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Edellinen kuukausi (PageUp)',
+  nextMonth: 'Seuraava kuukausi (PageDown)',
+  previousYear: 'Edellinen vuosi (Control + left)',
+  nextYear: 'Seuraava vuosi (Control + right)',
+  previousDecade: 'Edellinen vuosikymmen',
+  nextDecade: 'Seuraava vuosikymmen',
+  previousCentury: 'Edellinen vuosisata',
+  nextCentury: 'Seuraava vuosisata'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/fr_BE.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/fr_BE.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'fr_BE',
+  today: "Aujourd'hui",
+  now: 'Maintenant',
+  backToToday: "Aujourd'hui",
+  ok: 'Ok',
+  clear: 'Rétablir',
+  month: 'Mois',
+  year: 'Année',
+  timeSelect: "Sélectionner l'heure",
+  dateSelect: "Sélectionner l'heure",
+  monthSelect: 'Choisissez un mois',
+  yearSelect: 'Choisissez une année',
+  decadeSelect: 'Choisissez une décennie',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Mois précédent (PageUp)',
+  nextMonth: 'Mois suivant (PageDown)',
+  previousYear: 'Année précédente (Ctrl + gauche)',
+  nextYear: 'Année prochaine (Ctrl + droite)',
+  previousDecade: 'Décennie précédente',
+  nextDecade: 'Décennie suivante',
+  previousCentury: 'Siècle précédent',
+  nextCentury: 'Siècle suivant'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/fr_FR.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/fr_FR.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'fr_FR',
+  today: "Aujourd'hui",
+  now: 'Maintenant',
+  backToToday: "Aujourd'hui",
+  ok: 'Ok',
+  clear: 'Rétablir',
+  month: 'Mois',
+  year: 'Année',
+  timeSelect: "Sélectionner l'heure",
+  dateSelect: 'Sélectionner la date',
+  monthSelect: 'Choisissez un mois',
+  yearSelect: 'Choisissez une année',
+  decadeSelect: 'Choisissez une décennie',
+  yearFormat: 'YYYY',
+  dateFormat: 'DD/MM/YYYY',
+  dayFormat: 'DD',
+  dateTimeFormat: 'DD/MM/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Mois précédent (PageUp)',
+  nextMonth: 'Mois suivant (PageDown)',
+  previousYear: 'Année précédente (Ctrl + gauche)',
+  nextYear: 'Année prochaine (Ctrl + droite)',
+  previousDecade: 'Décennie précédente',
+  nextDecade: 'Décennie suivante',
+  previousCentury: 'Siècle précédent',
+  nextCentury: 'Siècle suivant'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/he_IL.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/he_IL.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'he_IL',
+  today: 'היום',
+  now: 'עכשיו',
+  backToToday: 'חזור להיום',
+  ok: 'אישור',
+  clear: 'איפוס',
+  month: 'חודש',
+  year: 'שנה',
+  timeSelect: 'בחר שעה',
+  dateSelect: 'בחר תאריך',
+  weekSelect: 'בחר שבוע',
+  monthSelect: 'בחר חודש',
+  yearSelect: 'בחר שנה',
+  decadeSelect: 'בחר עשור',
+  yearFormat: 'YYYY',
+  dateFormat: 'M/D/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'חודש קודם (PageUp)',
+  nextMonth: 'חודש הבא (PageDown)',
+  previousYear: 'שנה שעברה (Control + left)',
+  nextYear: 'שנה הבאה (Control + right)',
+  previousDecade: 'העשור הקודם',
+  nextDecade: 'העשור הבא',
+  previousCentury: 'המאה הקודמת',
+  nextCentury: 'המאה הבאה'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/hi_IN.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/hi_IN.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'hi_IN',
+  today: 'आज',
+  now: 'अभी',
+  backToToday: 'आज तक',
+  ok: 'ठीक',
+  clear: 'स्पष्ट',
+  month: 'महीना',
+  year: 'साल',
+  timeSelect: 'समय का चयन करें',
+  dateSelect: 'तारीख़ चुनें',
+  weekSelect: 'एक सप्ताह चुनें',
+  monthSelect: 'एक महीना चुनें',
+  yearSelect: 'एक वर्ष चुनें',
+  decadeSelect: 'एक दशक चुनें',
+  yearFormat: 'YYYY',
+  dateFormat: 'M/D/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'पिछला महीना (पेजअप)',
+  nextMonth: 'अगले महीने (पेजडाउन)',
+  previousYear: 'पिछले साल (Ctrl + बाएं)',
+  nextYear: 'अगले साल (Ctrl + दाहिना)',
+  previousDecade: 'पिछला दशक',
+  nextDecade: 'अगले दशक',
+  previousCentury: 'पीछ्ली शताब्दी',
+  nextCentury: 'अगली सदी'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/hr_HR.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/hr_HR.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'hr_HR',
+  today: 'Danas',
+  now: 'Sad',
+  backToToday: 'Natrag na danas',
+  ok: 'Ok',
+  clear: 'Očisti',
+  month: 'Mjesec',
+  year: 'Godina',
+  timeSelect: 'odaberite vrijeme',
+  dateSelect: 'odaberite datum',
+  weekSelect: 'Odaberite tjedan',
+  monthSelect: 'Odaberite mjesec',
+  yearSelect: 'Odaberite godinu',
+  decadeSelect: 'Odaberite desetljeće',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Prošli mjesec (PageUp)',
+  nextMonth: 'Sljedeći mjesec (PageDown)',
+  previousYear: 'Prošla godina (Control + left)',
+  nextYear: 'Sljedeća godina (Control + right)',
+  previousDecade: 'Prošlo desetljeće',
+  nextDecade: 'Sljedeće desetljeće',
+  previousCentury: 'Prošlo stoljeće',
+  nextCentury: 'Sljedeće stoljeće'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/hu_HU.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/hu_HU.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'hu_HU',
+  today: 'Ma',
+  now: 'Most',
+  backToToday: 'Vissza a mai napra',
+  ok: 'Ok',
+  clear: 'Törlés',
+  month: 'Hónap',
+  year: 'Év',
+  timeSelect: 'Időpont kiválasztása',
+  dateSelect: 'Dátum kiválasztása',
+  monthSelect: 'Hónap kiválasztása',
+  yearSelect: 'Év kiválasztása',
+  decadeSelect: 'Évtized kiválasztása',
+  yearFormat: 'YYYY',
+  dateFormat: 'YYYY/MM/DD',
+  dayFormat: 'DD',
+  dateTimeFormat: 'YYYY/MM/DD HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Előző hónap (PageUp)',
+  nextMonth: 'Következő hónap (PageDown)',
+  previousYear: 'Múlt év (Control + left)',
+  nextYear: 'Jövő év (Control + right)',
+  previousDecade: 'Előző évtized',
+  nextDecade: 'Következő évtized',
+  previousCentury: 'Múlt évszázad',
+  nextCentury: 'Jövő évszázad'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/id_ID.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/id_ID.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'id_ID',
+  today: 'Hari ini',
+  now: 'Sekarang',
+  backToToday: 'Kembali ke hari ini',
+  ok: 'Baik',
+  clear: 'Bersih',
+  month: 'Bulan',
+  year: 'Tahun',
+  timeSelect: 'pilih waktu',
+  dateSelect: 'pilih tanggal',
+  weekSelect: 'Pilih satu minggu',
+  monthSelect: 'Pilih satu bulan',
+  yearSelect: 'Pilih satu tahun',
+  decadeSelect: 'Pilih satu dekade',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Bulan sebelumnya (PageUp)',
+  nextMonth: 'Bulan selanjutnya (PageDown)',
+  previousYear: 'Tahun lalu (Control + kiri)',
+  nextYear: 'Tahun selanjutnya (Kontrol + kanan)',
+  previousDecade: 'Dekade terakhir',
+  nextDecade: 'Dekade berikutnya',
+  previousCentury: 'Abad terakhir',
+  nextCentury: 'Abad berikutnya'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/is_IS.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/is_IS.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'is_IS',
+  today: 'Í dag',
+  now: 'Núna',
+  backToToday: 'Til baka til dagsins í dag',
+  ok: 'Í lagi',
+  clear: 'Hreinsa',
+  month: 'Mánuður',
+  year: 'Ár',
+  timeSelect: 'Velja tíma',
+  dateSelect: 'Velja dag',
+  monthSelect: 'Velja mánuð',
+  yearSelect: 'Velja ár',
+  decadeSelect: 'Velja áratug',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Fyrri mánuður (PageUp)',
+  nextMonth: 'Næsti mánuður (PageDown)',
+  previousYear: 'Fyrra ár (Control + left)',
+  nextYear: 'Næsta ár (Control + right)',
+  previousDecade: 'Fyrri áratugur',
+  nextDecade: 'Næsti áratugur',
+  previousCentury: 'Fyrri öld',
+  nextCentury: 'Næsta öld'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/it_IT.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/it_IT.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'it_IT',
+  today: 'Oggi',
+  now: 'Adesso',
+  backToToday: 'Torna ad oggi',
+  ok: 'Ok',
+  clear: 'Cancella',
+  month: 'Mese',
+  year: 'Anno',
+  timeSelect: "Seleziona l'ora",
+  dateSelect: 'Seleziona la data',
+  monthSelect: 'Seleziona il mese',
+  yearSelect: "Seleziona l'anno",
+  decadeSelect: 'Seleziona il decennio',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Il mese scorso (PageUp)',
+  nextMonth: 'Il prossimo mese (PageDown)',
+  previousYear: "L'anno scorso (Control + sinistra)",
+  nextYear: "L'anno prossimo (Control + destra)",
+  previousDecade: 'Ultimo decennio',
+  nextDecade: 'Prossimo decennio',
+  previousCentury: 'Secolo precedente',
+  nextCentury: 'Prossimo secolo'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/ja_JP.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/ja_JP.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'ja_JP',
+  today: '今日',
+  now: '現在時刻',
+  backToToday: '今日に戻る',
+  ok: '決定',
+  timeSelect: '時間を選択',
+  dateSelect: '日時を選択',
+  weekSelect: '週を選択',
+  clear: 'クリア',
+  month: '月',
+  year: '年',
+  previousMonth: '前月 (ページアップキー)',
+  nextMonth: '翌月 (ページダウンキー)',
+  monthSelect: '月を選択',
+  yearSelect: '年を選択',
+  decadeSelect: '年代を選択',
+  yearFormat: 'YYYY年',
+  dayFormat: 'D日',
+  dateFormat: 'YYYY年M月D日',
+  dateTimeFormat: 'YYYY年M月D日 HH時mm分ss秒',
+  previousYear: '前年 (Controlを押しながら左キー)',
+  nextYear: '翌年 (Controlを押しながら右キー)',
+  previousDecade: '前の年代',
+  nextDecade: '次の年代',
+  previousCentury: '前の世紀',
+  nextCentury: '次の世紀'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/kn_IN.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/kn_IN.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'kn_IN',
+  today: 'ಇಂದು',
+  now: 'ಈಗ',
+  backToToday: 'ಇಂದು ಹಿಂದಿರುಗಿ',
+  ok: 'ಸರಿ',
+  clear: 'ಸ್ಪಷ್ಟ',
+  month: 'ತಿಂಗಳು',
+  year: 'ವರ್ಷ',
+  timeSelect: 'ಸಮಯ ಆಯ್ಕೆಮಾಡಿ',
+  dateSelect: 'ದಿನಾಂಕವನ್ನು ಆಯ್ಕೆ ಮಾಡಿ',
+  weekSelect: 'ಒಂದು ವಾರದ ಆರಿಸಿ',
+  monthSelect: 'ಒಂದು ತಿಂಗಳು ಆಯ್ಕೆಮಾಡಿ',
+  yearSelect: 'ಒಂದು ವರ್ಷ ಆರಿಸಿ',
+  decadeSelect: 'ಒಂದು ದಶಕದ ಆಯ್ಕೆಮಾಡಿ',
+  yearFormat: 'YYYY',
+  dateFormat: 'M/D/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'ಹಿಂದಿನ ತಿಂಗಳು (ಪೇಜ್ಅಪ್)',
+  nextMonth: 'ಮುಂದಿನ ತಿಂಗಳು (ಪೇಜ್ಡೌನ್)',
+  previousYear: 'ಕಳೆದ ವರ್ಷ (Ctrl + ಎಡ)',
+  nextYear: 'ಮುಂದಿನ ವರ್ಷ (Ctrl + ಬಲ)',
+  previousDecade: 'ಕಳೆದ ದಶಕ',
+  nextDecade: 'ಮುಂದಿನ ದಶಕ',
+  previousCentury: 'ಕಳೆದ ಶತಮಾನ',
+  nextCentury: 'ಮುಂದಿನ ಶತಮಾನ'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/ko_KR.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/ko_KR.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'ko_KR',
+  today: '오늘',
+  now: '현재 시각',
+  backToToday: '오늘로 돌아가기',
+  ok: '확인',
+  clear: '지우기',
+  month: '월',
+  year: '년',
+  timeSelect: '시간 선택',
+  dateSelect: '날짜 선택',
+  monthSelect: '달 선택',
+  yearSelect: '연 선택',
+  decadeSelect: '연대 선택',
+  yearFormat: 'YYYY년',
+  dateFormat: 'YYYY-MM-DD',
+  dayFormat: 'Do',
+  dateTimeFormat: 'YYYY-MM-DD HH:mm:ss',
+  monthBeforeYear: false,
+  previousMonth: '이전 달 (PageUp)',
+  nextMonth: '다음 달 (PageDown)',
+  previousYear: '이전 해 (Control + left)',
+  nextYear: '다음 해 (Control + right)',
+  previousDecade: '이전 연대',
+  nextDecade: '다음 연대',
+  previousCentury: '이전 세기',
+  nextCentury: '다음 세기'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/ku_IQ.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/ku_IQ.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'ku_IQ',
+  today: 'Îro',
+  now: 'Niha',
+  backToToday: 'Vegere îro',
+  ok: 'Temam',
+  clear: 'Paqij bike',
+  month: 'Meh',
+  year: 'Sal',
+  timeSelect: 'Demê hilbijêre',
+  dateSelect: 'Dîrok hilbijêre',
+  monthSelect: 'Meh hilbijêre',
+  yearSelect: 'Sal hilbijêre',
+  decadeSelect: 'Dehsal hilbijêre',
+  yearFormat: 'YYYY',
+  dateFormat: 'D/M/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D/M/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Meha peş (PageUp))',
+  nextMonth: 'Meha paş (PageDown)',
+  previousYear: 'Sala peş (Control + şep)',
+  nextYear: 'Sala paş (Control + rast)',
+  previousDecade: 'Dehsalen peş',
+  nextDecade: 'Dehsalen paş',
+  previousCentury: 'Sedsalen peş',
+  nextCentury: 'Sedsalen paş'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/lv_LV.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/lv_LV.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'lv_LV',
+  today: 'Šodien',
+  now: 'Tagad',
+  backToToday: 'Atpakaļ pie šodienas',
+  ok: 'Ok',
+  clear: 'Skaidrs',
+  month: 'Mēnesis',
+  year: 'Gads',
+  timeSelect: 'Izvēlieties laiku',
+  dateSelect: 'Izvēlieties datumu',
+  monthSelect: 'Izvēlieties mēnesi',
+  yearSelect: 'Izvēlieties gadu',
+  decadeSelect: 'Izvēlieties desmit gadus',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Iepriekšējais mēnesis (PageUp)',
+  nextMonth: 'Nākammēnes (PageDown)',
+  previousYear: 'Pagājušais gads (Control + left)',
+  nextYear: 'Nākamgad (Control + right)',
+  previousDecade: 'Pēdējā desmitgadē',
+  nextDecade: 'Nākamā desmitgade',
+  previousCentury: 'Pagājušajā gadsimtā',
+  nextCentury: 'Nākamajā gadsimtā'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/mk_MK.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/mk_MK.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'mk_MK',
+  today: 'Денес',
+  now: 'Сега',
+  backToToday: 'Назад до денес',
+  ok: 'ОК',
+  clear: 'Избриши',
+  month: 'Месец',
+  year: 'Година',
+  timeSelect: 'Избери време',
+  dateSelect: 'Избери датум',
+  monthSelect: 'Избери месец',
+  yearSelect: 'Избери година',
+  decadeSelect: 'Избери деценија',
+  yearFormat: 'YYYY',
+  dateFormat: 'D.M.YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'D.M.YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Претходен месец (PageUp)',
+  nextMonth: 'Нареден месец (PageDown)',
+  previousYear: 'Претходна година (Control + left)',
+  nextYear: 'Наредна година (Control + right)',
+  previousDecade: 'Претходна деценија',
+  nextDecade: 'Наредна деценија',
+  previousCentury: 'Претходен век',
+  nextCentury: 'Нареден век'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/mm_MM.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/mm_MM.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'mm_MM',
+  today: 'ယနေ့',
+  now: 'ယခု',
+  backToToday: 'ယနေ့ မတိုင်ခင် သို့',
+  ok: 'Ok',
+  clear: 'ရှင်းမည်',
+  month: 'လ',
+  year: 'နှစ်',
+  timeSelect: 'အချိန်ကို ရွေး',
+  dateSelect: 'နေ့ကို ရွေး',
+  weekSelect: 'အပတ်ကို ရွေး',
+  monthSelect: 'လကို ရွေး',
+  yearSelect: 'နှစ်ကို ရွေး',
+  decadeSelect: 'ဆယ်စုနှစ်ကို ရွေး',
+  yearFormat: 'YYYY',
+  dateFormat: 'M/D/YYYY',
+  dayFormat: 'D',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'ယခင် လ (PageUp)',
+  nextMonth: 'နောက် လ (PageDown)',
+  previousYear: 'ယခင် နှစ် (Control + left)',
+  nextYear: 'နောက် နှစ် (Control + right)',
+  previousDecade: 'ယခင် ဆယ်စုနှစ်',
+  nextDecade: 'နောက် ဆယ်စုနှစ်',
+  previousCentury: 'ယခင် ရာစုနှစ်',
+  nextCentury: 'နောက် ရာစုနှစ်'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/mn_MN.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/mn_MN.js

@@ -0,0 +1,30 @@
+var locale = {
+  locale: 'mn_MN',
+  today: 'Өнөөдөр',
+  now: 'Одоо',
+  backToToday: 'Өнөөдөрлүү буцах',
+  ok: 'Ok',
+  clear: 'Цэвэрлэх',
+  month: 'Сар',
+  year: 'Жил',
+  timeSelect: 'Цаг сонгох',
+  dateSelect: 'Огноо сонгох',
+  weekSelect: '7 хоног сонгох',
+  monthSelect: 'Сар сонгох',
+  yearSelect: 'Жил сонгох',
+  decadeSelect: 'Арван сонгох',
+  yearFormat: 'YYYY',
+  dateFormat: 'YYYY/MM/DD',
+  dayFormat: 'DD',
+  dateTimeFormat: 'YYYY/MM/DD HH:mm:ss',
+  monthBeforeYear: true,
+  previousMonth: 'Өмнөх сар (PageUp)',
+  nextMonth: 'Дараа сар (PageDown)',
+  previousYear: 'Өмнөх жил (Control + left)',
+  nextYear: 'Дараа жил (Control + right)',
+  previousDecade: 'Өмнөх арван',
+  nextDecade: 'Дараа арван',
+  previousCentury: 'Өмнөх зуун',
+  nextCentury: 'Дараа зуун'
+};
+export default locale;

web/node_modules/rc-picker/es/locale/ms_MY.d.ts

@@ -0,0 +1,3 @@
+import { Locale } from '../interface';
+declare const locale: Locale;
+export default locale;

web/node_modules/rc-picker/es/locale/ms_MY.js

@@ -0,0 +1,29 @@
+var locale = {
+  locale: 'ms_MY',
+  today: 'Hari ini',
+  now: 'Sekarang',
+  backToToday: 'Kembali ke hari ini',
+  ok: 'Ok',
+  timeSelect: 'Pilih masa',
+  dateSelect: 'Pilih tarikh',
+  weekSelect: 'Pilih minggu',
+  clear: 'Padam',
+  month: 'Bulan',
+  year: 'Tahun',
+  previousMonth: 'Bulan lepas',
+  nextMonth: 'Bulan depan',
+  monthSelect: 'Pilih bulan',
+  yearSelect: 'Pilih tahun',
+  decadeSelect: 'Pilih dekad',
+  yearFormat: 'YYYY',
+  dayFormat: 'D',
+  dateFormat: 'M/D/YYYY',
+  dateTimeFormat: 'M/D/YYYY HH:mm:ss',
+  previousYear: 'Tahun lepas (Ctrl+left)',
+  nextYear: 'Tahun depan (Ctrl+right)',
+  previousDecade: 'Dekad lepas',
+  nextDecade: 'Dekad depan',
+  previousCentury: 'Abad lepas',
+  nextCentury: 'Abad depan'
+};
+export default locale;