feat: initial commit - Phase 1 & 2 core features

frontend/node_modules/element-plus/es/components/time-picker/index.d.ts

@@ -0,0 +1,20 @@
+import { SFCWithInstall } from "../../utils/vue/typescript.js";
+import "../../utils/index.js";
+import { DateModelType, DateOrDates, DayOrDays, GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds, ModelValueType, PickerOptions, SingleOrRange, TimePickerDefaultProps, TimePickerDefaultPropsPublic, UserInput, timePickerDefaultProps, timePickerRangeTriggerProps, timePickerRngeTriggerProps } from "./src/common/props.js";
+import { _default as _default$2 } from "./src/time-picker.js";
+import { _default } from "./src/common/picker.vue.js";
+import { _default as _default$1 } from "./src/time-picker-com/panel-time-pick.vue.js";
+import { TimeList, buildTimeList, dateEquals, dayOrDaysToDate, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, valueEquals } from "./src/utils.js";
+import { DEFAULT_FORMATS_DATE, DEFAULT_FORMATS_DATEPICKER, DEFAULT_FORMATS_TIME, PICKER_BASE_INJECTION_KEY, PICKER_POPPER_OPTIONS_INJECTION_KEY, ROOT_COMMON_PICKER_INJECTION_KEY, TimeUnit, timeUnits } from "./src/constants.js";
+
+//#region ../../packages/components/time-picker/index.d.ts
+type TimePickerInstance = InstanceType<typeof _default$2> & TimePickerExpose;
+type TimePickerExpose = {
+  focus: () => void;
+  blur: () => void;
+  handleOpen: () => void;
+  handleClose: () => void;
+};
+declare const ElTimePicker: SFCWithInstall<typeof _default$2>;
+//#endregion
+export { _default as CommonPicker, DEFAULT_FORMATS_DATE, DEFAULT_FORMATS_DATEPICKER, DEFAULT_FORMATS_TIME, DateModelType, DateOrDates, DayOrDays, ElTimePicker, ElTimePicker as default, GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds, ModelValueType, PICKER_BASE_INJECTION_KEY, PICKER_POPPER_OPTIONS_INJECTION_KEY, PickerOptions, ROOT_COMMON_PICKER_INJECTION_KEY, SingleOrRange, TimeList, _default$1 as TimePickPanel, TimePickerDefaultProps, TimePickerDefaultPropsPublic, TimePickerExpose, TimePickerInstance, TimeUnit, UserInput, buildTimeList, dateEquals, dayOrDaysToDate, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, timePickerDefaultProps, timePickerRangeTriggerProps, timePickerRngeTriggerProps, timeUnits, valueEquals };

frontend/node_modules/element-plus/es/components/time-picker/index.mjs

@@ -0,0 +1,14 @@
+import { withInstall } from "../../utils/vue/install.mjs";
+import { DEFAULT_FORMATS_DATE, DEFAULT_FORMATS_DATEPICKER, DEFAULT_FORMATS_TIME, PICKER_BASE_INJECTION_KEY, PICKER_POPPER_OPTIONS_INJECTION_KEY, ROOT_COMMON_PICKER_INJECTION_KEY, timeUnits } from "./src/constants.mjs";
+import { buildTimeList, dateEquals, dayOrDaysToDate, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, valueEquals } from "./src/utils.mjs";
+import { timePickerDefaultProps, timePickerRangeTriggerProps, timePickerRngeTriggerProps } from "./src/common/props.mjs";
+import picker_default from "./src/common/picker.mjs";
+import panel_time_pick_default from "./src/time-picker-com/panel-time-pick.mjs";
+import time_picker_default from "./src/time-picker.mjs";
+
+//#region ../../packages/components/time-picker/index.ts
+const ElTimePicker = withInstall(time_picker_default);
+
+//#endregion
+export { picker_default as CommonPicker, DEFAULT_FORMATS_DATE, DEFAULT_FORMATS_DATEPICKER, DEFAULT_FORMATS_TIME, ElTimePicker, ElTimePicker as default, PICKER_BASE_INJECTION_KEY, PICKER_POPPER_OPTIONS_INJECTION_KEY, ROOT_COMMON_PICKER_INJECTION_KEY, panel_time_pick_default as TimePickPanel, buildTimeList, dateEquals, dayOrDaysToDate, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, timePickerDefaultProps, timePickerRangeTriggerProps, timePickerRngeTriggerProps, timeUnits, valueEquals };
+//# sourceMappingURL=index.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["TimePicker"],"sources":["../../../../../packages/components/time-picker/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport TimePicker from './src/time-picker'\nimport CommonPicker from './src/common/picker.vue'\nimport TimePickPanel from './src/time-picker-com/panel-time-pick.vue'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport type TimePickerInstance = InstanceType<typeof TimePicker> &\n  TimePickerExpose\nexport type TimePickerExpose = {\n  focus: () => void\n  blur: () => void\n  handleOpen: () => void\n  handleClose: () => void\n}\nexport * from './src/utils'\nexport * from './src/constants'\nexport * from './src/common/props'\n\nexport const ElTimePicker: SFCWithInstall<typeof TimePicker> =\n  withInstall(TimePicker)\n\nexport { CommonPicker, TimePickPanel }\nexport default ElTimePicker\n"],"mappings":";;;;;;;;;AAmBA,MAAa,eACX,YAAYA,oBAAW"}

frontend/node_modules/element-plus/es/components/time-picker/src/common/picker-range-trigger.mjs

@@ -0,0 +1,8 @@
+import picker_range_trigger_vue_vue_type_script_setup_true_lang_default from "./picker-range-trigger.vue_vue_type_script_setup_true_lang.mjs";
+
+//#region ../../packages/components/time-picker/src/common/picker-range-trigger.vue
+var picker_range_trigger_default = picker_range_trigger_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { picker_range_trigger_default as default };
+//# sourceMappingURL=picker-range-trigger.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/common/picker-range-trigger.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"picker-range-trigger.mjs","names":[],"sources":["../../../../../../../packages/components/time-picker/src/common/picker-range-trigger.vue"],"sourcesContent":["<template>\n  <div\n    ref=\"wrapperRef\"\n    :class=\"[nsDate.is('active', isFocused), $attrs.class]\"\n    :style=\"\n      // https://github.com/vuejs/language-tools/issues/2104#issuecomment-3092541527\n      $attrs.style as CSSProperties\n    \"\n    @click=\"handleClick\"\n    @mouseenter=\"handleMouseEnter\"\n    @mouseleave=\"handleMouseLeave\"\n    @touchstart.passive=\"handleTouchStart\"\n  >\n    <slot name=\"prefix\" />\n    <input\n      v-bind=\"attrs\"\n      :id=\"inputId\"\n      ref=\"inputRef\"\n      :name=\"name && name[0]\"\n      :placeholder=\"startPlaceholder\"\n      :value=\"modelValue && modelValue[0]\"\n      :class=\"nsRange.b('input')\"\n      :disabled=\"disabled\"\n      @input=\"handleStartInput\"\n      @change=\"handleStartChange\"\n    />\n    <slot name=\"range-separator\" />\n    <input\n      v-bind=\"attrs\"\n      :id=\"id && id[1]\"\n      ref=\"endInputRef\"\n      :name=\"name && name[1]\"\n      :placeholder=\"endPlaceholder\"\n      :value=\"modelValue && modelValue[1]\"\n      :class=\"nsRange.b('input')\"\n      :disabled=\"disabled\"\n      @input=\"handleEndInput\"\n      @change=\"handleEndChange\"\n    />\n    <slot name=\"suffix\" />\n  </div>\n</template>\n\n<script lang=\"ts\" setup>\nimport { computed, reactive, ref } from 'vue'\nimport { useAttrs, useFocusController, useNamespace } from '@element-plus/hooks'\nimport { timePickerRangeTriggerProps } from './props'\nimport { useFormItem, useFormItemInputId } from '@element-plus/components/form'\n\nimport type { CSSProperties } from 'vue'\n\ndefineOptions({\n  name: 'PickerRangeTrigger',\n  inheritAttrs: false,\n})\n\nconst props = defineProps(timePickerRangeTriggerProps)\nconst emit = defineEmits([\n  'mouseenter',\n  'mouseleave',\n  'click',\n  'touchstart',\n  'focus',\n  'blur',\n  'startInput',\n  'endInput',\n  'startChange',\n  'endChange',\n])\n\nconst { formItem } = useFormItem()\nconst { inputId } = useFormItemInputId(\n  reactive({ id: computed(() => props.id?.[0]) }),\n  {\n    formItemContext: formItem,\n  }\n)\n\nconst attrs = useAttrs()\nconst nsDate = useNamespace('date')\nconst nsRange = useNamespace('range')\n\nconst inputRef = ref<HTMLInputElement>()\nconst endInputRef = ref<HTMLInputElement>()\n\nconst { wrapperRef, isFocused } = useFocusController(inputRef, {\n  disabled: computed(() => props.disabled),\n})\n\nconst handleClick = (evt: MouseEvent) => {\n  emit('click', evt)\n}\n\nconst handleMouseEnter = (evt: MouseEvent) => {\n  emit('mouseenter', evt)\n}\n\nconst handleMouseLeave = (evt: MouseEvent) => {\n  emit('mouseleave', evt)\n}\n\nconst handleTouchStart = (evt: TouchEvent) => {\n  emit('touchstart', evt)\n}\n\nconst handleStartInput = (evt: Event) => {\n  emit('startInput', evt)\n}\n\nconst handleEndInput = (evt: Event) => {\n  emit('endInput', evt)\n}\n\nconst handleStartChange = (evt: Event) => {\n  emit('startChange', evt)\n}\n\nconst handleEndChange = (evt: Event) => {\n  emit('endChange', evt)\n}\n\nconst focus = () => {\n  inputRef.value?.focus()\n}\n\nconst blur = () => {\n  inputRef.value?.blur()\n  endInputRef.value?.blur()\n}\n\ndefineExpose({\n  focus,\n  blur,\n})\n</script>\n"],"mappings":""}

frontend/node_modules/element-plus/es/components/time-picker/src/common/picker-range-trigger.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,131 @@
+import { useAttrs as useAttrs$1 } from "../../../../hooks/use-attrs/index.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { useFocusController } from "../../../../hooks/use-focus-controller/index.mjs";
+import { useFormItem, useFormItemInputId } from "../../../form/src/hooks/use-form-item.mjs";
+import { timePickerRangeTriggerProps } from "./props.mjs";
+import { computed, createElementBlock, createElementVNode, defineComponent, mergeProps, normalizeClass, normalizeStyle, openBlock, reactive, ref, renderSlot, unref } from "vue";
+
+//#region ../../packages/components/time-picker/src/common/picker-range-trigger.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"id",
+	"name",
+	"placeholder",
+	"value",
+	"disabled"
+];
+const _hoisted_2 = [
+	"id",
+	"name",
+	"placeholder",
+	"value",
+	"disabled"
+];
+var picker_range_trigger_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "PickerRangeTrigger",
+	inheritAttrs: false,
+	__name: "picker-range-trigger",
+	props: timePickerRangeTriggerProps,
+	emits: [
+		"mouseenter",
+		"mouseleave",
+		"click",
+		"touchstart",
+		"focus",
+		"blur",
+		"startInput",
+		"endInput",
+		"startChange",
+		"endChange"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const { formItem } = useFormItem();
+		const { inputId } = useFormItemInputId(reactive({ id: computed(() => props.id?.[0]) }), { formItemContext: formItem });
+		const attrs = useAttrs$1();
+		const nsDate = useNamespace("date");
+		const nsRange = useNamespace("range");
+		const inputRef = ref();
+		const endInputRef = ref();
+		const { wrapperRef, isFocused } = useFocusController(inputRef, { disabled: computed(() => props.disabled) });
+		const handleClick = (evt) => {
+			emit("click", evt);
+		};
+		const handleMouseEnter = (evt) => {
+			emit("mouseenter", evt);
+		};
+		const handleMouseLeave = (evt) => {
+			emit("mouseleave", evt);
+		};
+		const handleTouchStart = (evt) => {
+			emit("touchstart", evt);
+		};
+		const handleStartInput = (evt) => {
+			emit("startInput", evt);
+		};
+		const handleEndInput = (evt) => {
+			emit("endInput", evt);
+		};
+		const handleStartChange = (evt) => {
+			emit("startChange", evt);
+		};
+		const handleEndChange = (evt) => {
+			emit("endChange", evt);
+		};
+		const focus = () => {
+			inputRef.value?.focus();
+		};
+		const blur = () => {
+			inputRef.value?.blur();
+			endInputRef.value?.blur();
+		};
+		__expose({
+			focus,
+			blur
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", {
+				ref_key: "wrapperRef",
+				ref: wrapperRef,
+				class: normalizeClass([unref(nsDate).is("active", unref(isFocused)), _ctx.$attrs.class]),
+				style: normalizeStyle(_ctx.$attrs.style),
+				onClick: handleClick,
+				onMouseenter: handleMouseEnter,
+				onMouseleave: handleMouseLeave,
+				onTouchstartPassive: handleTouchStart
+			}, [
+				renderSlot(_ctx.$slots, "prefix"),
+				createElementVNode("input", mergeProps(unref(attrs), {
+					id: unref(inputId),
+					ref_key: "inputRef",
+					ref: inputRef,
+					name: _ctx.name && _ctx.name[0],
+					placeholder: _ctx.startPlaceholder,
+					value: _ctx.modelValue && _ctx.modelValue[0],
+					class: unref(nsRange).b("input"),
+					disabled: _ctx.disabled,
+					onInput: handleStartInput,
+					onChange: handleStartChange
+				}), null, 16, _hoisted_1),
+				renderSlot(_ctx.$slots, "range-separator"),
+				createElementVNode("input", mergeProps(unref(attrs), {
+					id: _ctx.id && _ctx.id[1],
+					ref_key: "endInputRef",
+					ref: endInputRef,
+					name: _ctx.name && _ctx.name[1],
+					placeholder: _ctx.endPlaceholder,
+					value: _ctx.modelValue && _ctx.modelValue[1],
+					class: unref(nsRange).b("input"),
+					disabled: _ctx.disabled,
+					onInput: handleEndInput,
+					onChange: handleEndChange
+				}), null, 16, _hoisted_2),
+				renderSlot(_ctx.$slots, "suffix")
+			], 38);
+		};
+	}
+});
+
+//#endregion
+export { picker_range_trigger_vue_vue_type_script_setup_true_lang_default as default };
+//# sourceMappingURL=picker-range-trigger.vue_vue_type_script_setup_true_lang.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/common/picker.mjs

@@ -0,0 +1,8 @@
+import picker_vue_vue_type_script_setup_true_lang_default from "./picker.vue_vue_type_script_setup_true_lang.mjs";
+
+//#region ../../packages/components/time-picker/src/common/picker.vue
+var picker_default = picker_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { picker_default as default };
+//# sourceMappingURL=picker.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/common/picker.vue.d.ts

@@ -0,0 +1,520 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.js";
+import "../../../../utils/index.js";
+import { DayOrDays, GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds, ModelValueType, PickerOptions, SingleOrRange } from "./props.js";
+import * as vue from "vue";
+import * as _popperjs_core0 from "@popperjs/core";
+import { Options } from "@popperjs/core";
+import { Dayjs } from "dayjs";
+
+//#region ../../packages/components/time-picker/src/common/picker.vue.d.ts
+declare var __VLS_97: {}, __VLS_115: {
+    visible: boolean;
+    actualVisible: boolean;
+    parsedValue: DayOrDays;
+    format: string | undefined;
+    dateFormat: string | undefined;
+    timeFormat: string | undefined;
+    unlinkPanels: boolean;
+    type: string;
+    defaultValue: EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown> | undefined;
+    showNow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    showConfirm: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    showFooter: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    showWeekNumber: boolean;
+    onMousedown: () => void;
+    onPanelChange: (value: [Dayjs, Dayjs], mode: "month" | "year", view: unknown) => void;
+    onClear: (event?: MouseEvent) => void;
+    onCalendarChange: (e: [Date, null | Date]) => void;
+    onSetPickerOption: <T extends keyof PickerOptions>(e: [T, PickerOptions[T]]) => void;
+    onSelectRange: (start: number, end: number, pos?: "min" | "max") => void;
+    onPick: (date?: any, visible?: boolean) => void;
+  };
+type __VLS_Slots = {} & {
+  'range-separator'?: (props: typeof __VLS_97) => any;
+} & {
+  default?: (props: typeof __VLS_115) => any;
+};
+declare const __VLS_base: vue.DefineComponent<vue.ExtractPropTypes<{
+  readonly showNow: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showConfirm: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showFooter: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showWeekNumber: BooleanConstructor;
+  readonly ariaLabel: StringConstructor;
+  readonly emptyValues: ArrayConstructor;
+  readonly valueOnClear: EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+  readonly disabledDate: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly cellClassName: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly shortcuts: EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+  readonly arrowControl: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+  readonly validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly unlinkPanels: BooleanConstructor;
+  readonly placement: EpPropFinalized<(new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => _popperjs_core0.Placement) | (((new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => _popperjs_core0.Placement)) | null)[], _popperjs_core0.Placement, unknown, "bottom", boolean>;
+  readonly fallbackPlacements: EpPropFinalized<(new (...args: any[]) => _popperjs_core0.Placement[]) | (() => _popperjs_core0.Placement[]) | (((new (...args: any[]) => _popperjs_core0.Placement[]) | (() => _popperjs_core0.Placement[])) | null)[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
+  readonly disabledHours: {
+    readonly type: vue.PropType<GetDisabledHours>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly disabledMinutes: {
+    readonly type: vue.PropType<GetDisabledMinutes>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly disabledSeconds: {
+    readonly type: vue.PropType<GetDisabledSeconds>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly automaticDropdown: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly id: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly name: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly popperClass: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly popperStyle: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue) | (((new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly format: StringConstructor;
+  readonly valueFormat: StringConstructor;
+  readonly dateFormat: StringConstructor;
+  readonly timeFormat: StringConstructor;
+  readonly type: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly clearIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, boolean>;
+  readonly editable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly saveOnBlur: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly prefixIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, "", boolean>;
+  readonly size: {
+    readonly type: vue.PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly readonly: BooleanConstructor;
+  readonly disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  readonly placeholder: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly popperOptions: EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+  readonly modelValue: EpPropFinalized<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null)) | null)[], unknown, unknown, "", boolean>;
+  readonly rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
+  readonly startPlaceholder: StringConstructor;
+  readonly endPlaceholder: StringConstructor;
+  readonly defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultTime: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly isRange: BooleanConstructor;
+}>, {
+  /**
+   * @description focus input box.
+   */
+  focus: () => void;
+  /**
+   * @description blur input box.
+   */
+  blur: () => void;
+  /**
+   * @description opens picker
+   */
+  handleOpen: () => void;
+  /**
+   * @description closes picker
+   */
+  handleClose: () => void;
+  /**
+   * @description pick item manually
+   */
+  onPick: (date?: any, visible?: boolean) => void;
+}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+  blur: (...args: any[]) => void;
+  change: (...args: any[]) => void;
+  focus: (...args: any[]) => void;
+  keydown: (...args: any[]) => void;
+  "update:modelValue": (...args: any[]) => void;
+  clear: (...args: any[]) => void;
+  "calendar-change": (...args: any[]) => void;
+  "panel-change": (...args: any[]) => void;
+  "visible-change": (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  readonly showNow: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showConfirm: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showFooter: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showWeekNumber: BooleanConstructor;
+  readonly ariaLabel: StringConstructor;
+  readonly emptyValues: ArrayConstructor;
+  readonly valueOnClear: EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+  readonly disabledDate: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly cellClassName: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly shortcuts: EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+  readonly arrowControl: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+  readonly validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly unlinkPanels: BooleanConstructor;
+  readonly placement: EpPropFinalized<(new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => _popperjs_core0.Placement) | (((new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => _popperjs_core0.Placement)) | null)[], _popperjs_core0.Placement, unknown, "bottom", boolean>;
+  readonly fallbackPlacements: EpPropFinalized<(new (...args: any[]) => _popperjs_core0.Placement[]) | (() => _popperjs_core0.Placement[]) | (((new (...args: any[]) => _popperjs_core0.Placement[]) | (() => _popperjs_core0.Placement[])) | null)[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
+  readonly disabledHours: {
+    readonly type: vue.PropType<GetDisabledHours>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly disabledMinutes: {
+    readonly type: vue.PropType<GetDisabledMinutes>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly disabledSeconds: {
+    readonly type: vue.PropType<GetDisabledSeconds>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly automaticDropdown: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly id: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly name: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly popperClass: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly popperStyle: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue) | (((new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly format: StringConstructor;
+  readonly valueFormat: StringConstructor;
+  readonly dateFormat: StringConstructor;
+  readonly timeFormat: StringConstructor;
+  readonly type: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly clearIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, boolean>;
+  readonly editable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly saveOnBlur: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly prefixIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, "", boolean>;
+  readonly size: {
+    readonly type: vue.PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly readonly: BooleanConstructor;
+  readonly disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  readonly placeholder: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly popperOptions: EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+  readonly modelValue: EpPropFinalized<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null)) | null)[], unknown, unknown, "", boolean>;
+  readonly rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
+  readonly startPlaceholder: StringConstructor;
+  readonly endPlaceholder: StringConstructor;
+  readonly defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultTime: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly isRange: BooleanConstructor;
+}>> & Readonly<{
+  onBlur?: ((...args: any[]) => any) | undefined;
+  onChange?: ((...args: any[]) => any) | undefined;
+  onFocus?: ((...args: any[]) => any) | undefined;
+  onKeydown?: ((...args: any[]) => any) | undefined;
+  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+  onClear?: ((...args: any[]) => any) | undefined;
+  "onCalendar-change"?: ((...args: any[]) => any) | undefined;
+  "onPanel-change"?: ((...args: any[]) => any) | undefined;
+  "onVisible-change"?: ((...args: any[]) => any) | undefined;
+}>, {
+  readonly type: string;
+  readonly disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly modelValue: EpPropMergeType<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null)) | null)[], unknown, unknown>;
+  readonly placeholder: string;
+  readonly readonly: boolean;
+  readonly clearable: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly clearIcon: EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown>;
+  readonly prefixIcon: EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown>;
+  readonly tabindex: EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+  readonly validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly fallbackPlacements: _popperjs_core0.Placement[];
+  readonly placement: EpPropMergeType<(new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => _popperjs_core0.Placement) | (((new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => _popperjs_core0.Placement)) | null)[], _popperjs_core0.Placement, unknown>;
+  readonly popperOptions: Partial<Options>;
+  readonly valueOnClear: EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
+  readonly automaticDropdown: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly editable: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly saveOnBlur: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly rangeSeparator: string;
+  readonly shortcuts: unknown[];
+  readonly showNow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly showConfirm: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly showFooter: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly showWeekNumber: boolean;
+  readonly arrowControl: boolean;
+  readonly unlinkPanels: boolean;
+  readonly isRange: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { _default };

frontend/node_modules/element-plus/es/components/time-picker/src/common/picker.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,526 @@
+import { EVENT_CODE } from "../../../../constants/aria.mjs";
+import { CHANGE_EVENT, UPDATE_MODEL_EVENT } from "../../../../constants/event.mjs";
+import { getEventCode } from "../../../../utils/dom/event.mjs";
+import { isArray } from "../../../../utils/types.mjs";
+import { debugWarn } from "../../../../utils/error.mjs";
+import { NOOP } from "../../../../utils/functions.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { useFocusController } from "../../../../hooks/use-focus-controller/index.mjs";
+import { useEmptyValues } from "../../../../hooks/use-empty-values/index.mjs";
+import { ElIcon } from "../../../icon/index.mjs";
+import { useFormDisabled, useFormSize } from "../../../form/src/hooks/use-form-common-props.mjs";
+import { useFormItem } from "../../../form/src/hooks/use-form-item.mjs";
+import { ElTooltip } from "../../../tooltip/index.mjs";
+import { ElInput } from "../../../input/index.mjs";
+import { PICKER_BASE_INJECTION_KEY, PICKER_POPPER_OPTIONS_INJECTION_KEY, ROOT_COMMON_PICKER_INJECTION_KEY } from "../constants.mjs";
+import { dayOrDaysToDate, valueEquals } from "../utils.mjs";
+import { useCommonPicker } from "../composables/use-common-picker.mjs";
+import { timePickerDefaultProps } from "./props.mjs";
+import picker_range_trigger_default from "./picker-range-trigger.mjs";
+import { onClickOutside, unrefElement } from "@vueuse/core";
+import { Calendar, Clock } from "@element-plus/icons-vue";
+import { computed, createBlock, createCommentVNode, createElementVNode, defineComponent, inject, mergeProps, nextTick, normalizeClass, normalizeStyle, onBeforeUnmount, openBlock, provide, ref, renderSlot, resolveDynamicComponent, toDisplayString, unref, useAttrs, watch, withCtx, withModifiers } from "vue";
+
+//#region ../../packages/components/time-picker/src/common/picker.vue?vue&type=script&setup=true&lang.ts
+var picker_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	name: "Picker",
+	__name: "picker",
+	props: timePickerDefaultProps,
+	emits: [
+		UPDATE_MODEL_EVENT,
+		CHANGE_EVENT,
+		"focus",
+		"blur",
+		"clear",
+		"calendar-change",
+		"panel-change",
+		"visible-change",
+		"keydown"
+	],
+	setup(__props, { expose: __expose, emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const attrs = useAttrs();
+		const nsDate = useNamespace("date");
+		const nsInput = useNamespace("input");
+		const nsRange = useNamespace("range");
+		const { formItem } = useFormItem();
+		const elPopperOptions = inject(PICKER_POPPER_OPTIONS_INJECTION_KEY, {});
+		const emptyValues = useEmptyValues(props, null);
+		const refPopper = ref();
+		const inputRef = ref();
+		const valueOnOpen = ref(null);
+		let hasJustTabExitedInput = false;
+		const pickerDisabled = useFormDisabled();
+		const commonPicker = useCommonPicker(props, emit);
+		const { parsedValue, pickerActualVisible, userInput, pickerVisible, pickerOptions, valueIsEmpty, emitInput, onPick, onSetPickerOption, onCalendarChange, onPanelChange } = commonPicker;
+		const { isFocused, handleFocus, handleBlur } = useFocusController(inputRef, {
+			disabled: pickerDisabled,
+			beforeFocus() {
+				return props.readonly;
+			},
+			afterFocus() {
+				if (!props.automaticDropdown) return;
+				pickerVisible.value = true;
+			},
+			beforeBlur(event) {
+				return !hasJustTabExitedInput && refPopper.value?.isFocusInsideContent(event);
+			},
+			afterBlur() {
+				if (isTimePicker.value && !props.saveOnBlur) {
+					if (!valueIsEmpty.value) pickerOptions.value.handleCancel?.();
+				} else handleChange();
+				pickerVisible.value = false;
+				hasJustTabExitedInput = false;
+				props.validateEvent && formItem?.validate("blur").catch((err) => debugWarn(err));
+			}
+		});
+		const hovering = ref(false);
+		const rangeInputKls = computed(() => [
+			nsDate.b("editor"),
+			nsDate.bm("editor", props.type),
+			nsInput.e("wrapper"),
+			nsDate.is("disabled", pickerDisabled.value),
+			nsDate.is("active", pickerVisible.value),
+			nsRange.b("editor"),
+			pickerSize ? nsRange.bm("editor", pickerSize.value) : "",
+			attrs.class
+		]);
+		const clearIconKls = computed(() => [
+			nsInput.e("icon"),
+			nsRange.e("close-icon"),
+			!showClearBtn.value ? nsRange.em("close-icon", "hidden") : ""
+		]);
+		watch(pickerVisible, (val) => {
+			if (!val) {
+				userInput.value = null;
+				nextTick(() => {
+					emitChange(props.modelValue);
+				});
+			} else nextTick(() => {
+				if (val) valueOnOpen.value = props.modelValue;
+			});
+		});
+		const emitChange = (val, isClear) => {
+			if (isClear || !valueEquals(val, valueOnOpen.value)) {
+				emit(CHANGE_EVENT, val);
+				isClear && (valueOnOpen.value = val);
+				props.validateEvent && formItem?.validate("change").catch((err) => debugWarn(err));
+			}
+		};
+		const emitKeydown = (e) => {
+			emit("keydown", e);
+		};
+		const refInput = computed(() => {
+			if (inputRef.value) return Array.from(inputRef.value.$el.querySelectorAll("input"));
+			return [];
+		});
+		const setSelectionRange = (start, end, pos) => {
+			const _inputs = refInput.value;
+			if (!_inputs.length) return;
+			if (!pos || pos === "min") {
+				_inputs[0].setSelectionRange(start, end);
+				_inputs[0].focus();
+			} else if (pos === "max") {
+				_inputs[1].setSelectionRange(start, end);
+				_inputs[1].focus();
+			}
+		};
+		const onBeforeShow = () => {
+			pickerActualVisible.value = true;
+		};
+		const onShow = () => {
+			emit("visible-change", true);
+		};
+		const onHide = () => {
+			pickerActualVisible.value = false;
+			pickerVisible.value = false;
+			emit("visible-change", false);
+		};
+		const handleOpen = () => {
+			pickerVisible.value = true;
+		};
+		const handleClose = () => {
+			pickerVisible.value = false;
+		};
+		const displayValue = computed(() => {
+			const formattedValue = formatToString(parsedValue.value);
+			if (isArray(userInput.value)) return [userInput.value[0] ?? (formattedValue && formattedValue[0]) ?? "", userInput.value[1] ?? (formattedValue && formattedValue[1]) ?? ""];
+			else if (userInput.value !== null) return userInput.value;
+			if (isTimePicker.value && valueIsEmpty.value && !props.saveOnBlur) return "";
+			if (!isTimePicker.value && valueIsEmpty.value) return "";
+			if (!pickerVisible.value && valueIsEmpty.value) return "";
+			if (formattedValue) return isDatesPicker.value || isMonthsPicker.value || isYearsPicker.value ? formattedValue.join(", ") : formattedValue;
+			return "";
+		});
+		const isTimeLikePicker = computed(() => props.type.includes("time"));
+		const isTimePicker = computed(() => props.type.startsWith("time"));
+		const isDatesPicker = computed(() => props.type === "dates");
+		const isMonthsPicker = computed(() => props.type === "months");
+		const isYearsPicker = computed(() => props.type === "years");
+		const triggerIcon = computed(() => props.prefixIcon || (isTimeLikePicker.value ? Clock : Calendar));
+		const showClearBtn = computed(() => props.clearable && !pickerDisabled.value && !props.readonly && !valueIsEmpty.value && (hovering.value || isFocused.value));
+		const onClear = (event) => {
+			if (props.readonly || pickerDisabled.value) return;
+			if (showClearBtn.value) {
+				event?.stopPropagation();
+				if (pickerOptions.value.handleClear) pickerOptions.value.handleClear();
+				else emitInput(emptyValues.valueOnClear.value);
+				emitChange(emptyValues.valueOnClear.value, true);
+				onHide();
+			}
+			emit("clear");
+		};
+		const onMouseDownInput = async (event) => {
+			if (props.readonly || pickerDisabled.value) return;
+			if (event.target?.tagName !== "INPUT" || isFocused.value || !props.automaticDropdown) pickerVisible.value = true;
+		};
+		const onMouseEnter = () => {
+			if (props.readonly || pickerDisabled.value) return;
+			if (!valueIsEmpty.value && props.clearable) hovering.value = true;
+		};
+		const onMouseLeave = () => {
+			hovering.value = false;
+		};
+		const onTouchStartInput = (event) => {
+			if (props.readonly || pickerDisabled.value) return;
+			if (event.touches[0].target?.tagName !== "INPUT" || isFocused.value || !props.automaticDropdown) pickerVisible.value = true;
+		};
+		const isRangeInput = computed(() => {
+			return props.type.includes("range");
+		});
+		const pickerSize = useFormSize();
+		const popperEl = computed(() => unref(refPopper)?.popperRef?.contentRef);
+		const stophandle = onClickOutside(inputRef, (e) => {
+			const unrefedPopperEl = unref(popperEl);
+			const inputEl = unrefElement(inputRef);
+			if (unrefedPopperEl && (e.target === unrefedPopperEl || e.composedPath().includes(unrefedPopperEl)) || e.target === inputEl || inputEl && e.composedPath().includes(inputEl)) return;
+			pickerVisible.value = false;
+		});
+		onBeforeUnmount(() => {
+			stophandle?.();
+		});
+		const handleChange = () => {
+			if (isTimePicker.value && !props.saveOnBlur) return;
+			const isRangeEmpty = isArray(userInput.value) && userInput.value.every((v) => v === "");
+			if (userInput.value && !isRangeEmpty) {
+				const value = parseUserInputToDayjs(displayValue.value);
+				if (value) {
+					if (isValidValue(value)) emitInput(dayOrDaysToDate(value));
+					userInput.value = null;
+				}
+			}
+			if (userInput.value === "" || isRangeEmpty) {
+				emitInput(emptyValues.valueOnClear.value);
+				emitChange(emptyValues.valueOnClear.value, true);
+				userInput.value = null;
+			}
+		};
+		const parseUserInputToDayjs = (value) => {
+			if (!value) return null;
+			return pickerOptions.value.parseUserInput(value);
+		};
+		const formatToString = (value) => {
+			if (!value) return null;
+			return isArray(value) ? value.map((_) => _.format(props.format)) : value.format(props.format);
+		};
+		const isValidValue = (value) => {
+			return pickerOptions.value.isValidValue(value);
+		};
+		const handleKeydownInput = async (event) => {
+			if (props.readonly || pickerDisabled.value) return;
+			const code = getEventCode(event);
+			emitKeydown(event);
+			if (code === EVENT_CODE.esc) {
+				if (pickerVisible.value === true) {
+					pickerVisible.value = false;
+					event.preventDefault();
+					event.stopPropagation();
+				}
+				return;
+			}
+			if (code === EVENT_CODE.down) {
+				if (pickerOptions.value.handleFocusPicker) {
+					event.preventDefault();
+					event.stopPropagation();
+				}
+				if (pickerVisible.value === false) {
+					pickerVisible.value = true;
+					await nextTick();
+				}
+				if (pickerOptions.value.handleFocusPicker) {
+					pickerOptions.value.handleFocusPicker();
+					return;
+				}
+			}
+			if (code === EVENT_CODE.tab) {
+				hasJustTabExitedInput = true;
+				return;
+			}
+			if (code === EVENT_CODE.enter || code === EVENT_CODE.numpadEnter) {
+				if (!pickerVisible.value) pickerVisible.value = true;
+				else if (userInput.value === null || userInput.value === "" || isValidValue(parseUserInputToDayjs(displayValue.value))) {
+					handleChange();
+					pickerVisible.value = false;
+				}
+				event.preventDefault();
+				event.stopPropagation();
+				return;
+			}
+			if (userInput.value) {
+				event.stopPropagation();
+				return;
+			}
+			if (pickerOptions.value.handleKeydownInput) pickerOptions.value.handleKeydownInput(event);
+		};
+		const onUserInput = (e) => {
+			userInput.value = e;
+			if (!pickerVisible.value) pickerVisible.value = true;
+		};
+		const handleStartInput = (event) => {
+			const target = event.target;
+			if (userInput.value) userInput.value = [target.value, userInput.value[1]];
+			else userInput.value = [target.value, null];
+		};
+		const handleEndInput = (event) => {
+			const target = event.target;
+			if (userInput.value) userInput.value = [userInput.value[0], target.value];
+			else userInput.value = [null, target.value];
+		};
+		const handleStartChange = () => {
+			const values = userInput.value;
+			const value = parseUserInputToDayjs(values && values[0]);
+			const parsedVal = unref(parsedValue);
+			if (value && value.isValid()) {
+				userInput.value = [formatToString(value), displayValue.value?.[1] || null];
+				const newValue = [value, parsedVal && (parsedVal[1] || null)];
+				if (isValidValue(newValue)) {
+					emitInput(dayOrDaysToDate(newValue));
+					userInput.value = null;
+				}
+			}
+		};
+		const handleEndChange = () => {
+			const values = unref(userInput);
+			const value = parseUserInputToDayjs(values && values[1]);
+			const parsedVal = unref(parsedValue);
+			if (value && value.isValid()) {
+				userInput.value = [unref(displayValue)?.[0] || null, formatToString(value)];
+				const newValue = [parsedVal && parsedVal[0], value];
+				if (isValidValue(newValue)) {
+					emitInput(dayOrDaysToDate(newValue));
+					userInput.value = null;
+				}
+			}
+		};
+		const focus = () => {
+			inputRef.value?.focus();
+		};
+		const blur = () => {
+			inputRef.value?.blur();
+		};
+		provide(PICKER_BASE_INJECTION_KEY, {
+			props,
+			emptyValues
+		});
+		provide(ROOT_COMMON_PICKER_INJECTION_KEY, commonPicker);
+		__expose({
+			focus,
+			blur,
+			handleOpen,
+			handleClose,
+			onPick
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(unref(ElTooltip), mergeProps({
+				ref_key: "refPopper",
+				ref: refPopper,
+				visible: unref(pickerVisible),
+				effect: "light",
+				pure: "",
+				trigger: "click"
+			}, _ctx.$attrs, {
+				role: "dialog",
+				teleported: "",
+				transition: `${unref(nsDate).namespace.value}-zoom-in-top`,
+				"popper-class": [`${unref(nsDate).namespace.value}-picker__popper`, _ctx.popperClass],
+				"popper-style": _ctx.popperStyle,
+				"popper-options": unref(elPopperOptions),
+				"fallback-placements": _ctx.fallbackPlacements,
+				"gpu-acceleration": false,
+				placement: _ctx.placement,
+				"stop-popper-mouse-event": false,
+				"hide-after": 0,
+				persistent: "",
+				onBeforeShow,
+				onShow,
+				onHide
+			}), {
+				default: withCtx(() => [!isRangeInput.value ? (openBlock(), createBlock(unref(ElInput), {
+					key: 0,
+					id: _ctx.id,
+					ref_key: "inputRef",
+					ref: inputRef,
+					"container-role": "combobox",
+					"model-value": displayValue.value,
+					name: _ctx.name,
+					size: unref(pickerSize),
+					disabled: unref(pickerDisabled),
+					placeholder: _ctx.placeholder,
+					class: normalizeClass([
+						unref(nsDate).b("editor"),
+						unref(nsDate).bm("editor", _ctx.type),
+						unref(nsDate).is("focus", unref(pickerVisible)),
+						_ctx.$attrs.class
+					]),
+					style: normalizeStyle(_ctx.$attrs.style),
+					readonly: !_ctx.editable || _ctx.readonly || isDatesPicker.value || isMonthsPicker.value || isYearsPicker.value || _ctx.type === "week",
+					"aria-label": _ctx.ariaLabel,
+					tabindex: _ctx.tabindex,
+					"validate-event": false,
+					onInput: onUserInput,
+					onFocus: unref(handleFocus),
+					onBlur: unref(handleBlur),
+					onKeydown: handleKeydownInput,
+					onChange: handleChange,
+					onMousedown: onMouseDownInput,
+					onMouseenter: onMouseEnter,
+					onMouseleave: onMouseLeave,
+					onTouchstartPassive: onTouchStartInput,
+					onClick: _cache[0] || (_cache[0] = withModifiers(() => {}, ["stop"]))
+				}, {
+					prefix: withCtx(() => [triggerIcon.value ? (openBlock(), createBlock(unref(ElIcon), {
+						key: 0,
+						class: normalizeClass(unref(nsInput).e("icon")),
+						onMousedown: withModifiers(onMouseDownInput, ["prevent"]),
+						onTouchstartPassive: onTouchStartInput
+					}, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(triggerIcon.value)))]),
+						_: 1
+					}, 8, ["class"])) : createCommentVNode("v-if", true)]),
+					suffix: withCtx(() => [showClearBtn.value && _ctx.clearIcon ? (openBlock(), createBlock(unref(ElIcon), {
+						key: 0,
+						class: normalizeClass(`${unref(nsInput).e("icon")} clear-icon`),
+						onMousedown: withModifiers(unref(NOOP), ["prevent"]),
+						onClick: onClear
+					}, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))]),
+						_: 1
+					}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true)]),
+					_: 1
+				}, 8, [
+					"id",
+					"model-value",
+					"name",
+					"size",
+					"disabled",
+					"placeholder",
+					"class",
+					"style",
+					"readonly",
+					"aria-label",
+					"tabindex",
+					"onFocus",
+					"onBlur"
+				])) : (openBlock(), createBlock(picker_range_trigger_default, {
+					key: 1,
+					id: _ctx.id,
+					ref_key: "inputRef",
+					ref: inputRef,
+					"model-value": displayValue.value,
+					name: _ctx.name,
+					disabled: unref(pickerDisabled),
+					readonly: !_ctx.editable || _ctx.readonly,
+					"start-placeholder": _ctx.startPlaceholder,
+					"end-placeholder": _ctx.endPlaceholder,
+					class: normalizeClass(rangeInputKls.value),
+					style: normalizeStyle(_ctx.$attrs.style),
+					"aria-label": _ctx.ariaLabel,
+					tabindex: _ctx.tabindex,
+					autocomplete: "off",
+					role: "combobox",
+					onClick: onMouseDownInput,
+					onFocus: unref(handleFocus),
+					onBlur: unref(handleBlur),
+					onStartInput: handleStartInput,
+					onStartChange: handleStartChange,
+					onEndInput: handleEndInput,
+					onEndChange: handleEndChange,
+					onMousedown: onMouseDownInput,
+					onMouseenter: onMouseEnter,
+					onMouseleave: onMouseLeave,
+					onTouchstartPassive: onTouchStartInput,
+					onKeydown: handleKeydownInput
+				}, {
+					prefix: withCtx(() => [triggerIcon.value ? (openBlock(), createBlock(unref(ElIcon), {
+						key: 0,
+						class: normalizeClass([unref(nsInput).e("icon"), unref(nsRange).e("icon")])
+					}, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(triggerIcon.value)))]),
+						_: 1
+					}, 8, ["class"])) : createCommentVNode("v-if", true)]),
+					"range-separator": withCtx(() => [renderSlot(_ctx.$slots, "range-separator", {}, () => [createElementVNode("span", { class: normalizeClass(unref(nsRange).b("separator")) }, toDisplayString(_ctx.rangeSeparator), 3)])]),
+					suffix: withCtx(() => [_ctx.clearIcon ? (openBlock(), createBlock(unref(ElIcon), {
+						key: 0,
+						class: normalizeClass(clearIconKls.value),
+						onMousedown: withModifiers(unref(NOOP), ["prevent"]),
+						onClick: onClear
+					}, {
+						default: withCtx(() => [(openBlock(), createBlock(resolveDynamicComponent(_ctx.clearIcon)))]),
+						_: 1
+					}, 8, ["class", "onMousedown"])) : createCommentVNode("v-if", true)]),
+					_: 3
+				}, 8, [
+					"id",
+					"model-value",
+					"name",
+					"disabled",
+					"readonly",
+					"start-placeholder",
+					"end-placeholder",
+					"class",
+					"style",
+					"aria-label",
+					"tabindex",
+					"onFocus",
+					"onBlur"
+				]))]),
+				content: withCtx(() => [renderSlot(_ctx.$slots, "default", {
+					visible: unref(pickerVisible),
+					actualVisible: unref(pickerActualVisible),
+					parsedValue: unref(parsedValue),
+					format: _ctx.format,
+					dateFormat: _ctx.dateFormat,
+					timeFormat: _ctx.timeFormat,
+					unlinkPanels: _ctx.unlinkPanels,
+					type: _ctx.type,
+					defaultValue: _ctx.defaultValue,
+					showNow: _ctx.showNow,
+					showConfirm: _ctx.showConfirm,
+					showFooter: _ctx.showFooter,
+					showWeekNumber: _ctx.showWeekNumber,
+					onPick: _cache[1] || (_cache[1] = (...args) => unref(onPick) && unref(onPick)(...args)),
+					onSelectRange: setSelectionRange,
+					onSetPickerOption: _cache[2] || (_cache[2] = (...args) => unref(onSetPickerOption) && unref(onSetPickerOption)(...args)),
+					onCalendarChange: _cache[3] || (_cache[3] = (...args) => unref(onCalendarChange) && unref(onCalendarChange)(...args)),
+					onClear,
+					onPanelChange: _cache[4] || (_cache[4] = (...args) => unref(onPanelChange) && unref(onPanelChange)(...args)),
+					onMousedown: _cache[5] || (_cache[5] = withModifiers(() => {}, ["stop"]))
+				})]),
+				_: 3
+			}, 16, [
+				"visible",
+				"transition",
+				"popper-class",
+				"popper-style",
+				"popper-options",
+				"fallback-placements",
+				"placement"
+			]);
+		};
+	}
+});
+
+//#endregion
+export { picker_vue_vue_type_script_setup_true_lang_default as default };
+//# sourceMappingURL=picker.vue_vue_type_script_setup_true_lang.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/common/props.d.ts

@@ -0,0 +1,286 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.js";
+import "../../../../utils/index.js";
+import { Placement as Placement$1 } from "../../../popper/index.js";
+import * as vue from "vue";
+import { Component, ExtractPropTypes, ExtractPublicPropTypes } from "vue";
+import { Options } from "@popperjs/core";
+import { Dayjs } from "dayjs";
+
+//#region ../../packages/components/time-picker/src/common/props.d.ts
+type SingleOrRange<T> = T | [T, T];
+type DateModelType = number | string | Date;
+type ModelValueType = DateModelType | number[] | string[] | Date[];
+type DayOrDays = SingleOrRange<Dayjs>;
+type DateOrDates = SingleOrRange<Date>;
+type UserInput = SingleOrRange<string | null>;
+type GetDisabledHours = (role: string, comparingDate?: Dayjs) => number[];
+type GetDisabledMinutes = (hour: number, role: string, comparingDate?: Dayjs) => number[];
+type GetDisabledSeconds = (hour: number, minute: number, role: string, comparingDate?: Dayjs) => number[];
+declare const timePickerDefaultProps: {
+  readonly showNow: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showConfirm: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showFooter: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly showWeekNumber: BooleanConstructor;
+  readonly ariaLabel: StringConstructor;
+  readonly emptyValues: ArrayConstructor;
+  readonly valueOnClear: EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+  readonly disabledDate: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly cellClassName: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly shortcuts: EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+  readonly arrowControl: BooleanConstructor;
+  readonly tabindex: EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+  readonly validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly unlinkPanels: BooleanConstructor;
+  readonly placement: EpPropFinalized<(new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement$1) | (((new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement$1)) | null)[], Placement$1, unknown, "bottom", boolean>;
+  readonly fallbackPlacements: EpPropFinalized<(new (...args: any[]) => Placement$1[]) | (() => Placement$1[]) | (((new (...args: any[]) => Placement$1[]) | (() => Placement$1[])) | null)[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
+  readonly disabledHours: {
+    readonly type: vue.PropType<GetDisabledHours>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly disabledMinutes: {
+    readonly type: vue.PropType<GetDisabledMinutes>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly disabledSeconds: {
+    readonly type: vue.PropType<GetDisabledSeconds>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly automaticDropdown: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly id: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly name: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly popperClass: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly popperStyle: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue) | (((new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly format: StringConstructor;
+  readonly valueFormat: StringConstructor;
+  readonly dateFormat: StringConstructor;
+  readonly timeFormat: StringConstructor;
+  readonly type: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly clearIcon: EpPropFinalized<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown, vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, boolean>;
+  readonly editable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly saveOnBlur: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly prefixIcon: EpPropFinalized<(new (...args: any[]) => (string | Component) & {}) | (() => string | Component) | (((new (...args: any[]) => (string | Component) & {}) | (() => string | Component)) | null)[], unknown, unknown, "", boolean>;
+  readonly size: {
+    readonly type: vue.PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly readonly: BooleanConstructor;
+  readonly disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  readonly placeholder: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  readonly popperOptions: EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+  readonly modelValue: EpPropFinalized<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null)) | null)[], unknown, unknown, "", boolean>;
+  readonly rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
+  readonly startPlaceholder: StringConstructor;
+  readonly endPlaceholder: StringConstructor;
+  readonly defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly defaultTime: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly isRange: BooleanConstructor;
+};
+type TimePickerDefaultProps = ExtractPropTypes<typeof timePickerDefaultProps>;
+type TimePickerDefaultPropsPublic = ExtractPublicPropTypes<typeof timePickerDefaultProps>;
+interface PickerOptions {
+  isValidValue: (date: DayOrDays) => boolean;
+  handleKeydownInput: (event: KeyboardEvent) => void;
+  parseUserInput: (value: UserInput) => DayOrDays;
+  getRangeAvailableTime: (date: DayOrDays) => DayOrDays;
+  getDefaultValue: () => DayOrDays;
+  panelReady: boolean;
+  handleClear: () => void;
+  handleFocusPicker?: () => void;
+  handleCancel?: () => void;
+}
+declare const timePickerRangeTriggerProps: {
+  readonly id: {
+    readonly type: vue.PropType<string[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly name: {
+    readonly type: vue.PropType<string[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly modelValue: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput) | (((new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly startPlaceholder: StringConstructor;
+  readonly endPlaceholder: StringConstructor;
+  readonly disabled: BooleanConstructor;
+};
+/**
+ * @deprecated Use `timePickerRangeTriggerProps` instead. This will be removed in future versions.
+ */
+declare const timePickerRngeTriggerProps: {
+  readonly id: {
+    readonly type: vue.PropType<string[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly name: {
+    readonly type: vue.PropType<string[]>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly modelValue: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput) | (((new (...args: any[]) => string | [string | null, string | null]) | (() => UserInput)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly startPlaceholder: StringConstructor;
+  readonly endPlaceholder: StringConstructor;
+  readonly disabled: BooleanConstructor;
+};
+//#endregion
+export { DateModelType, DateOrDates, DayOrDays, GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds, ModelValueType, PickerOptions, SingleOrRange, TimePickerDefaultProps, TimePickerDefaultPropsPublic, UserInput, timePickerDefaultProps, timePickerRangeTriggerProps, timePickerRngeTriggerProps };

frontend/node_modules/element-plus/es/components/time-picker/src/common/props.mjs

@@ -0,0 +1,142 @@
+import { buildProps, definePropType } from "../../../../utils/vue/props/runtime.mjs";
+import { useSizeProp } from "../../../../hooks/use-size/index.mjs";
+import { useEmptyValuesProps } from "../../../../hooks/use-empty-values/index.mjs";
+import { useAriaProps } from "../../../../hooks/use-aria/index.mjs";
+import { useTooltipContentProps } from "../../../tooltip/src/content.mjs";
+import { disabledTimeListsProps } from "../props/shared.mjs";
+import { CircleClose } from "@element-plus/icons-vue";
+import { placements } from "@popperjs/core";
+
+//#region ../../packages/components/time-picker/src/common/props.ts
+const timePickerDefaultProps = buildProps({
+	automaticDropdown: {
+		type: Boolean,
+		default: true
+	},
+	id: { type: definePropType([Array, String]) },
+	name: { type: definePropType([Array, String]) },
+	popperClass: useTooltipContentProps.popperClass,
+	popperStyle: useTooltipContentProps.popperStyle,
+	format: String,
+	valueFormat: String,
+	dateFormat: String,
+	timeFormat: String,
+	type: {
+		type: String,
+		default: ""
+	},
+	clearable: {
+		type: Boolean,
+		default: true
+	},
+	clearIcon: {
+		type: definePropType([String, Object]),
+		default: CircleClose
+	},
+	editable: {
+		type: Boolean,
+		default: true
+	},
+	saveOnBlur: {
+		type: Boolean,
+		default: true
+	},
+	prefixIcon: {
+		type: definePropType([String, Object]),
+		default: ""
+	},
+	size: useSizeProp,
+	readonly: Boolean,
+	disabled: {
+		type: Boolean,
+		default: void 0
+	},
+	placeholder: {
+		type: String,
+		default: ""
+	},
+	popperOptions: {
+		type: definePropType(Object),
+		default: () => ({})
+	},
+	modelValue: {
+		type: definePropType([
+			Date,
+			Array,
+			String,
+			Number
+		]),
+		default: ""
+	},
+	rangeSeparator: {
+		type: String,
+		default: "-"
+	},
+	startPlaceholder: String,
+	endPlaceholder: String,
+	defaultValue: { type: definePropType([Date, Array]) },
+	defaultTime: { type: definePropType([Date, Array]) },
+	isRange: Boolean,
+	...disabledTimeListsProps,
+	disabledDate: { type: Function },
+	cellClassName: { type: Function },
+	shortcuts: {
+		type: Array,
+		default: () => []
+	},
+	arrowControl: Boolean,
+	tabindex: {
+		type: definePropType([String, Number]),
+		default: 0
+	},
+	validateEvent: {
+		type: Boolean,
+		default: true
+	},
+	unlinkPanels: Boolean,
+	placement: {
+		type: definePropType(String),
+		values: placements,
+		default: "bottom"
+	},
+	fallbackPlacements: {
+		type: definePropType(Array),
+		default: [
+			"bottom",
+			"top",
+			"right",
+			"left"
+		]
+	},
+	...useEmptyValuesProps,
+	...useAriaProps(["ariaLabel"]),
+	showNow: {
+		type: Boolean,
+		default: true
+	},
+	showConfirm: {
+		type: Boolean,
+		default: true
+	},
+	showFooter: {
+		type: Boolean,
+		default: true
+	},
+	showWeekNumber: Boolean
+});
+const timePickerRangeTriggerProps = buildProps({
+	id: { type: definePropType(Array) },
+	name: { type: definePropType(Array) },
+	modelValue: { type: definePropType([Array, String]) },
+	startPlaceholder: String,
+	endPlaceholder: String,
+	disabled: Boolean
+});
+/**
+* @deprecated Use `timePickerRangeTriggerProps` instead. This will be removed in future versions.
+*/
+const timePickerRngeTriggerProps = timePickerRangeTriggerProps;
+
+//#endregion
+export { timePickerDefaultProps, timePickerRangeTriggerProps, timePickerRngeTriggerProps };
+//# sourceMappingURL=props.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/composables/use-common-picker.d.ts

@@ -0,0 +1,46 @@
+import { DateModelType, DayOrDays, ModelValueType, PickerOptions, SingleOrRange, UserInput } from "../common/props.js";
+import * as vue from "vue";
+import { Dayjs } from "dayjs";
+
+//#region ../../packages/components/time-picker/src/composables/use-common-picker.d.ts
+interface CommonPickerProps {
+  modelValue: ModelValueType | null;
+  valueFormat?: string;
+}
+type CommonPickerEmits = (event: 'update:modelValue' | 'calendar-change' | 'panel-change', ...args: any[]) => void;
+declare const useCommonPicker: <P extends CommonPickerProps, E extends CommonPickerEmits>(props: P, emit: E) => {
+  parsedValue: vue.ComputedRef<DayOrDays>;
+  pickerActualVisible: vue.Ref<boolean, boolean>;
+  pickerOptions: vue.Ref<{
+    isValidValue?: ((date: DayOrDays) => boolean) | undefined;
+    handleKeydownInput?: ((event: KeyboardEvent) => void) | undefined;
+    parseUserInput?: ((value: UserInput) => DayOrDays) | undefined;
+    getRangeAvailableTime?: ((date: DayOrDays) => DayOrDays) | undefined;
+    getDefaultValue?: (() => DayOrDays) | undefined;
+    panelReady?: boolean | undefined;
+    handleClear?: (() => void) | undefined;
+    handleFocusPicker?: (() => void) | undefined;
+    handleCancel?: (() => void) | undefined;
+  }, Partial<PickerOptions> | {
+    isValidValue?: ((date: DayOrDays) => boolean) | undefined;
+    handleKeydownInput?: ((event: KeyboardEvent) => void) | undefined;
+    parseUserInput?: ((value: UserInput) => DayOrDays) | undefined;
+    getRangeAvailableTime?: ((date: DayOrDays) => DayOrDays) | undefined;
+    getDefaultValue?: (() => DayOrDays) | undefined;
+    panelReady?: boolean | undefined;
+    handleClear?: (() => void) | undefined;
+    handleFocusPicker?: (() => void) | undefined;
+    handleCancel?: (() => void) | undefined;
+  }>;
+  pickerVisible: vue.Ref<boolean, boolean>;
+  userInput: vue.Ref<UserInput, UserInput>;
+  valueIsEmpty: vue.ComputedRef<boolean>;
+  emitInput: (input: SingleOrRange<DateModelType> | null) => void;
+  onCalendarChange: (e: [Date, null | Date]) => void;
+  onPanelChange: (value: [Dayjs, Dayjs], mode: "month" | "year", view: unknown) => void;
+  onPick: (date?: any, visible?: boolean) => void;
+  onSetPickerOption: <T extends keyof PickerOptions>(e: [T, PickerOptions[T]]) => void;
+};
+type CommonPickerContext = ReturnType<typeof useCommonPicker>;
+//#endregion
+export { CommonPickerContext };

frontend/node_modules/element-plus/es/components/time-picker/src/composables/use-common-picker.mjs

@@ -0,0 +1,78 @@
+import { UPDATE_MODEL_EVENT } from "../../../../constants/event.mjs";
+import { isArray } from "../../../../utils/types.mjs";
+import { useLocale } from "../../../../hooks/use-locale/index.mjs";
+import { dayOrDaysToDate, formatter, parseDate, valueEquals } from "../utils.mjs";
+import { isEqual } from "lodash-unified";
+import { computed, ref } from "vue";
+
+//#region ../../packages/components/time-picker/src/composables/use-common-picker.ts
+const useCommonPicker = (props, emit) => {
+	const { lang } = useLocale();
+	const pickerVisible = ref(false);
+	const pickerActualVisible = ref(false);
+	const userInput = ref(null);
+	const valueIsEmpty = computed(() => {
+		const { modelValue } = props;
+		return !modelValue || isArray(modelValue) && !modelValue.filter(Boolean).length;
+	});
+	const emitInput = (input) => {
+		if (!valueEquals(props.modelValue, input)) {
+			let formatted;
+			if (isArray(input)) formatted = input.map((item) => formatter(item, props.valueFormat, lang.value));
+			else if (input) formatted = formatter(input, props.valueFormat, lang.value);
+			emit(UPDATE_MODEL_EVENT, input ? formatted : input, lang.value);
+		}
+	};
+	const parsedValue = computed(() => {
+		let dayOrDays;
+		if (valueIsEmpty.value) {
+			if (pickerOptions.value.getDefaultValue) dayOrDays = pickerOptions.value.getDefaultValue();
+		} else if (isArray(props.modelValue)) dayOrDays = props.modelValue.map((d) => parseDate(d, props.valueFormat, lang.value));
+		else dayOrDays = parseDate(props.modelValue ?? "", props.valueFormat, lang.value);
+		if (pickerOptions.value.getRangeAvailableTime) {
+			const availableResult = pickerOptions.value.getRangeAvailableTime(dayOrDays);
+			if (!isEqual(availableResult, dayOrDays)) {
+				dayOrDays = availableResult;
+				if (!valueIsEmpty.value) emitInput(dayOrDaysToDate(dayOrDays));
+			}
+		}
+		if (isArray(dayOrDays) && dayOrDays.some((day) => !day)) dayOrDays = [];
+		return dayOrDays;
+	});
+	const pickerOptions = ref({});
+	const onSetPickerOption = (e) => {
+		pickerOptions.value[e[0]] = e[1];
+		pickerOptions.value.panelReady = true;
+	};
+	const onCalendarChange = (e) => {
+		emit("calendar-change", e);
+	};
+	const onPanelChange = (value, mode, view) => {
+		emit("panel-change", value, mode, view);
+	};
+	const onPick = (date = "", visible = false) => {
+		pickerVisible.value = visible;
+		let result;
+		if (isArray(date)) result = date.map((_) => _.toDate());
+		else result = date ? date.toDate() : date;
+		userInput.value = null;
+		emitInput(result);
+	};
+	return {
+		parsedValue,
+		pickerActualVisible,
+		pickerOptions,
+		pickerVisible,
+		userInput,
+		valueIsEmpty,
+		emitInput,
+		onCalendarChange,
+		onPanelChange,
+		onPick,
+		onSetPickerOption
+	};
+};
+
+//#endregion
+export { useCommonPicker };
+//# sourceMappingURL=use-common-picker.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/composables/use-time-panel.mjs

@@ -0,0 +1,50 @@
+//#region ../../packages/components/time-picker/src/composables/use-time-panel.ts
+const useTimePanel = ({ getAvailableHours, getAvailableMinutes, getAvailableSeconds }) => {
+	const getAvailableTime = (date, role, first, compareDate) => {
+		const availableTimeGetters = {
+			hour: getAvailableHours,
+			minute: getAvailableMinutes,
+			second: getAvailableSeconds
+		};
+		let result = date;
+		[
+			"hour",
+			"minute",
+			"second"
+		].forEach((type) => {
+			if (availableTimeGetters[type]) {
+				let availableTimeSlots;
+				const method = availableTimeGetters[type];
+				switch (type) {
+					case "minute":
+						availableTimeSlots = method(result.hour(), role, compareDate);
+						break;
+					case "second":
+						availableTimeSlots = method(result.hour(), result.minute(), role, compareDate);
+						break;
+					default:
+						availableTimeSlots = method(role, compareDate);
+						break;
+				}
+				if (availableTimeSlots?.length && !availableTimeSlots.includes(result[type]())) {
+					const pos = first ? 0 : availableTimeSlots.length - 1;
+					result = result[type](availableTimeSlots[pos]);
+				}
+			}
+		});
+		return result;
+	};
+	const timePickerOptions = {};
+	const onSetOption = ([key, val]) => {
+		timePickerOptions[key] = val;
+	};
+	return {
+		timePickerOptions,
+		getAvailableTime,
+		onSetOption
+	};
+};
+
+//#endregion
+export { useTimePanel };
+//# sourceMappingURL=use-time-panel.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/composables/use-time-panel.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-time-panel.mjs","names":[],"sources":["../../../../../../../packages/components/time-picker/src/composables/use-time-panel.ts"],"sourcesContent":["import type { Dayjs } from 'dayjs'\nimport type {\n  GetDisabledHours,\n  GetDisabledMinutes,\n  GetDisabledSeconds,\n} from '../common/props'\n\ntype UseTimePanelProps = {\n  getAvailableHours: GetDisabledHours\n  getAvailableMinutes: GetDisabledMinutes\n  getAvailableSeconds: GetDisabledSeconds\n}\n\nexport const useTimePanel = ({\n  getAvailableHours,\n  getAvailableMinutes,\n  getAvailableSeconds,\n}: UseTimePanelProps) => {\n  const getAvailableTime = (\n    date: Dayjs,\n    role: string,\n    first: boolean,\n    compareDate?: Dayjs\n  ) => {\n    const availableTimeGetters = {\n      hour: getAvailableHours,\n      minute: getAvailableMinutes,\n      second: getAvailableSeconds,\n    } as const\n    let result = date\n    ;(['hour', 'minute', 'second'] as const).forEach((type) => {\n      if (availableTimeGetters[type]) {\n        let availableTimeSlots: number[]\n        const method = availableTimeGetters[type]\n        switch (type) {\n          case 'minute': {\n            availableTimeSlots = (method as typeof getAvailableMinutes)(\n              result.hour(),\n              role,\n              compareDate\n            )\n            break\n          }\n          case 'second': {\n            availableTimeSlots = (method as typeof getAvailableSeconds)(\n              result.hour(),\n              result.minute(),\n              role,\n              compareDate\n            )\n            break\n          }\n          default: {\n            availableTimeSlots = (method as typeof getAvailableHours)(\n              role,\n              compareDate\n            )\n            break\n          }\n        }\n\n        if (\n          availableTimeSlots?.length &&\n          !availableTimeSlots.includes(result[type]())\n        ) {\n          const pos = first ? 0 : availableTimeSlots.length - 1\n          result = result[type](availableTimeSlots[pos]) as unknown as Dayjs\n        }\n      }\n    })\n    return result\n  }\n\n  const timePickerOptions: Record<string, (...args: any[]) => void> = {}\n\n  const onSetOption = ([key, val]: [string, (...args: any[]) => void]) => {\n    timePickerOptions[key] = val\n  }\n\n  return {\n    timePickerOptions,\n\n    getAvailableTime,\n    onSetOption,\n  }\n}\n"],"mappings":";AAaA,MAAa,gBAAgB,EAC3B,mBACA,qBACA,0BACuB;CACvB,MAAM,oBACJ,MACA,MACA,OACA,gBACG;EACH,MAAM,uBAAuB;GAC3B,MAAM;GACN,QAAQ;GACR,QAAQ;GACT;EACD,IAAI,SAAS;AACZ,EAAC;GAAC;GAAQ;GAAU;GAAS,CAAW,SAAS,SAAS;AACzD,OAAI,qBAAqB,OAAO;IAC9B,IAAI;IACJ,MAAM,SAAS,qBAAqB;AACpC,YAAQ,MAAR;KACE,KAAK;AACH,2BAAsB,OACpB,OAAO,MAAM,EACb,MACA,YACD;AACD;KAEF,KAAK;AACH,2BAAsB,OACpB,OAAO,MAAM,EACb,OAAO,QAAQ,EACf,MACA,YACD;AACD;KAEF;AACE,2BAAsB,OACpB,MACA,YACD;AACD;;AAIJ,QACE,oBAAoB,UACpB,CAAC,mBAAmB,SAAS,OAAO,OAAO,CAAC,EAC5C;KACA,MAAM,MAAM,QAAQ,IAAI,mBAAmB,SAAS;AACpD,cAAS,OAAO,MAAM,mBAAmB,KAAK;;;IAGlD;AACF,SAAO;;CAGT,MAAM,oBAA8D,EAAE;CAEtE,MAAM,eAAe,CAAC,KAAK,SAA6C;AACtE,oBAAkB,OAAO;;AAG3B,QAAO;EACL;EAEA;EACA;EACD"}

frontend/node_modules/element-plus/es/components/time-picker/src/composables/use-time-picker.mjs

@@ -0,0 +1,59 @@
+import { makeList } from "../utils.mjs";
+import { ref, toValue, watch } from "vue";
+
+//#region ../../packages/components/time-picker/src/composables/use-time-picker.ts
+const makeAvailableArr = (disabledList) => {
+	const trueOrNumber = (isDisabled, index) => isDisabled || index;
+	const getNumber = (predicate) => predicate !== true;
+	return disabledList.map(trueOrNumber).filter(getNumber);
+};
+const getTimeLists = (disabledHours, disabledMinutes, disabledSeconds) => {
+	const getHoursList = (role, compare) => {
+		return makeList(24, disabledHours && (() => disabledHours?.(role, compare)));
+	};
+	const getMinutesList = (hour, role, compare) => {
+		return makeList(60, disabledMinutes && (() => disabledMinutes?.(hour, role, compare)));
+	};
+	const getSecondsList = (hour, minute, role, compare) => {
+		return makeList(60, disabledSeconds && (() => disabledSeconds?.(hour, minute, role, compare)));
+	};
+	return {
+		getHoursList,
+		getMinutesList,
+		getSecondsList
+	};
+};
+const buildAvailableTimeSlotGetter = (disabledHours, disabledMinutes, disabledSeconds) => {
+	const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(disabledHours, disabledMinutes, disabledSeconds);
+	const getAvailableHours = (role, compare) => {
+		return makeAvailableArr(getHoursList(role, compare));
+	};
+	const getAvailableMinutes = (hour, role, compare) => {
+		return makeAvailableArr(getMinutesList(hour, role, compare));
+	};
+	const getAvailableSeconds = (hour, minute, role, compare) => {
+		return makeAvailableArr(getSecondsList(hour, minute, role, compare));
+	};
+	return {
+		getAvailableHours,
+		getAvailableMinutes,
+		getAvailableSeconds
+	};
+};
+const useOldValue = (props, options) => {
+	const oldValue = ref(props.parsedValue);
+	watch(() => props.visible, (val) => {
+		const modelValue = toValue(options.modelValue);
+		const valueOnClear = toValue(options.valueOnClear);
+		if (val && modelValue === valueOnClear) {
+			oldValue.value = valueOnClear;
+			return;
+		}
+		if (!val) oldValue.value = props.parsedValue;
+	});
+	return oldValue;
+};
+
+//#endregion
+export { buildAvailableTimeSlotGetter, getTimeLists, useOldValue };
+//# sourceMappingURL=use-time-picker.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/composables/use-time-picker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-time-picker.mjs","names":[],"sources":["../../../../../../../packages/components/time-picker/src/composables/use-time-picker.ts"],"sourcesContent":["import { ref, toValue, watch } from 'vue'\nimport { makeList } from '../utils'\n\nimport type { MaybeRefOrGetter } from 'vue'\nimport type { Dayjs } from 'dayjs'\nimport type {\n  GetDisabledHours,\n  GetDisabledMinutes,\n  GetDisabledSeconds,\n} from '../common/props'\n\nconst makeAvailableArr = (disabledList: boolean[]): number[] => {\n  const trueOrNumber = (isDisabled: boolean, index: number) =>\n    isDisabled || index\n\n  const getNumber = (predicate: number | true): predicate is number =>\n    predicate !== true\n\n  return disabledList.map(trueOrNumber).filter(getNumber)\n}\n\nexport const getTimeLists = (\n  disabledHours?: GetDisabledHours,\n  disabledMinutes?: GetDisabledMinutes,\n  disabledSeconds?: GetDisabledSeconds\n) => {\n  const getHoursList = (role: string, compare?: Dayjs) => {\n    return makeList(24, disabledHours && (() => disabledHours?.(role, compare)))\n  }\n\n  const getMinutesList = (hour: number, role: string, compare?: Dayjs) => {\n    return makeList(\n      60,\n      disabledMinutes && (() => disabledMinutes?.(hour, role, compare))\n    )\n  }\n\n  const getSecondsList = (\n    hour: number,\n    minute: number,\n    role: string,\n    compare?: Dayjs\n  ) => {\n    return makeList(\n      60,\n      disabledSeconds && (() => disabledSeconds?.(hour, minute, role, compare))\n    )\n  }\n\n  return {\n    getHoursList,\n    getMinutesList,\n    getSecondsList,\n  }\n}\n\nexport const buildAvailableTimeSlotGetter = (\n  disabledHours: GetDisabledHours,\n  disabledMinutes: GetDisabledMinutes,\n  disabledSeconds: GetDisabledSeconds\n) => {\n  const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(\n    disabledHours,\n    disabledMinutes,\n    disabledSeconds\n  )\n\n  const getAvailableHours: GetDisabledHours = (role, compare?) => {\n    return makeAvailableArr(getHoursList(role, compare))\n  }\n\n  const getAvailableMinutes: GetDisabledMinutes = (hour, role, compare?) => {\n    return makeAvailableArr(getMinutesList(hour, role, compare))\n  }\n\n  const getAvailableSeconds: GetDisabledSeconds = (\n    hour,\n    minute,\n    role,\n    compare?\n  ) => {\n    return makeAvailableArr(getSecondsList(hour, minute, role, compare))\n  }\n\n  return {\n    getAvailableHours,\n    getAvailableMinutes,\n    getAvailableSeconds,\n  }\n}\n\nexport const useOldValue = (\n  props: {\n    parsedValue?: string | Dayjs | Dayjs[]\n    visible: boolean\n  },\n  options: {\n    modelValue: MaybeRefOrGetter<unknown>\n    valueOnClear: MaybeRefOrGetter<unknown>\n  }\n) => {\n  const oldValue = ref(props.parsedValue)\n\n  watch(\n    () => props.visible,\n    (val) => {\n      const modelValue = toValue(options.modelValue)\n      const valueOnClear = toValue(options.valueOnClear)\n      if (val && modelValue === valueOnClear) {\n        oldValue.value = valueOnClear as typeof oldValue.value\n        return\n      }\n      if (!val) {\n        oldValue.value = props.parsedValue\n      }\n    }\n  )\n\n  return oldValue\n}\n"],"mappings":";;;;AAWA,MAAM,oBAAoB,iBAAsC;CAC9D,MAAM,gBAAgB,YAAqB,UACzC,cAAc;CAEhB,MAAM,aAAa,cACjB,cAAc;AAEhB,QAAO,aAAa,IAAI,aAAa,CAAC,OAAO,UAAU;;AAGzD,MAAa,gBACX,eACA,iBACA,oBACG;CACH,MAAM,gBAAgB,MAAc,YAAoB;AACtD,SAAO,SAAS,IAAI,wBAAwB,gBAAgB,MAAM,QAAQ,EAAE;;CAG9E,MAAM,kBAAkB,MAAc,MAAc,YAAoB;AACtE,SAAO,SACL,IACA,0BAA0B,kBAAkB,MAAM,MAAM,QAAQ,EACjE;;CAGH,MAAM,kBACJ,MACA,QACA,MACA,YACG;AACH,SAAO,SACL,IACA,0BAA0B,kBAAkB,MAAM,QAAQ,MAAM,QAAQ,EACzE;;AAGH,QAAO;EACL;EACA;EACA;EACD;;AAGH,MAAa,gCACX,eACA,iBACA,oBACG;CACH,MAAM,EAAE,cAAc,gBAAgB,mBAAmB,aACvD,eACA,iBACA,gBACD;CAED,MAAM,qBAAuC,MAAM,YAAa;AAC9D,SAAO,iBAAiB,aAAa,MAAM,QAAQ,CAAC;;CAGtD,MAAM,uBAA2C,MAAM,MAAM,YAAa;AACxE,SAAO,iBAAiB,eAAe,MAAM,MAAM,QAAQ,CAAC;;CAG9D,MAAM,uBACJ,MACA,QACA,MACA,YACG;AACH,SAAO,iBAAiB,eAAe,MAAM,QAAQ,MAAM,QAAQ,CAAC;;AAGtE,QAAO;EACL;EACA;EACA;EACD;;AAGH,MAAa,eACX,OAIA,YAIG;CACH,MAAM,WAAW,IAAI,MAAM,YAAY;AAEvC,aACQ,MAAM,UACX,QAAQ;EACP,MAAM,aAAa,QAAQ,QAAQ,WAAW;EAC9C,MAAM,eAAe,QAAQ,QAAQ,aAAa;AAClD,MAAI,OAAO,eAAe,cAAc;AACtC,YAAS,QAAQ;AACjB;;AAEF,MAAI,CAAC,IACH,UAAS,QAAQ,MAAM;GAG5B;AAED,QAAO"}

frontend/node_modules/element-plus/es/components/time-picker/src/constants.d.ts

@@ -0,0 +1,27 @@
+import { CommonPickerContext } from "./composables/use-common-picker.js";
+import { InjectionKey } from "vue";
+
+//#region ../../packages/components/time-picker/src/constants.d.ts
+declare const timeUnits: readonly ["hours", "minutes", "seconds"];
+declare const PICKER_BASE_INJECTION_KEY = "EP_PICKER_BASE";
+declare const PICKER_POPPER_OPTIONS_INJECTION_KEY = "ElPopperOptions";
+declare const ROOT_COMMON_PICKER_INJECTION_KEY: InjectionKey<CommonPickerContext>;
+declare const DEFAULT_FORMATS_TIME = "HH:mm:ss";
+declare const DEFAULT_FORMATS_DATE = "YYYY-MM-DD";
+declare const DEFAULT_FORMATS_DATEPICKER: {
+  date: string;
+  dates: string;
+  week: string;
+  year: string;
+  years: string;
+  month: string;
+  months: string;
+  datetime: string;
+  monthrange: string;
+  yearrange: string;
+  daterange: string;
+  datetimerange: string;
+};
+type TimeUnit = (typeof timeUnits)[number];
+//#endregion
+export { DEFAULT_FORMATS_DATE, DEFAULT_FORMATS_DATEPICKER, DEFAULT_FORMATS_TIME, PICKER_BASE_INJECTION_KEY, PICKER_POPPER_OPTIONS_INJECTION_KEY, ROOT_COMMON_PICKER_INJECTION_KEY, TimeUnit, timeUnits };

frontend/node_modules/element-plus/es/components/time-picker/src/constants.mjs

@@ -0,0 +1,29 @@
+//#region ../../packages/components/time-picker/src/constants.ts
+const timeUnits = [
+	"hours",
+	"minutes",
+	"seconds"
+];
+const PICKER_BASE_INJECTION_KEY = "EP_PICKER_BASE";
+const PICKER_POPPER_OPTIONS_INJECTION_KEY = "ElPopperOptions";
+const ROOT_COMMON_PICKER_INJECTION_KEY = Symbol("commonPickerContextKey");
+const DEFAULT_FORMATS_TIME = "HH:mm:ss";
+const DEFAULT_FORMATS_DATE = "YYYY-MM-DD";
+const DEFAULT_FORMATS_DATEPICKER = {
+	date: DEFAULT_FORMATS_DATE,
+	dates: DEFAULT_FORMATS_DATE,
+	week: "gggg[w]ww",
+	year: "YYYY",
+	years: "YYYY",
+	month: "YYYY-MM",
+	months: "YYYY-MM",
+	datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,
+	monthrange: "YYYY-MM",
+	yearrange: "YYYY",
+	daterange: DEFAULT_FORMATS_DATE,
+	datetimerange: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`
+};
+
+//#endregion
+export { DEFAULT_FORMATS_DATE, DEFAULT_FORMATS_DATEPICKER, DEFAULT_FORMATS_TIME, PICKER_BASE_INJECTION_KEY, PICKER_POPPER_OPTIONS_INJECTION_KEY, ROOT_COMMON_PICKER_INJECTION_KEY, timeUnits };
+//# sourceMappingURL=constants.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":[],"sources":["../../../../../../packages/components/time-picker/src/constants.ts"],"sourcesContent":["import type { InjectionKey } from 'vue'\nimport type { CommonPickerContext } from './composables/use-common-picker'\n\nexport const timeUnits = ['hours', 'minutes', 'seconds'] as const\n\nexport const PICKER_BASE_INJECTION_KEY = 'EP_PICKER_BASE'\n\nexport const PICKER_POPPER_OPTIONS_INJECTION_KEY = 'ElPopperOptions'\n\nexport const ROOT_COMMON_PICKER_INJECTION_KEY: InjectionKey<CommonPickerContext> =\n  Symbol('commonPickerContextKey')\n\nexport const DEFAULT_FORMATS_TIME = 'HH:mm:ss'\n\nexport const DEFAULT_FORMATS_DATE = 'YYYY-MM-DD'\n\nexport const DEFAULT_FORMATS_DATEPICKER = {\n  date: DEFAULT_FORMATS_DATE,\n  dates: DEFAULT_FORMATS_DATE,\n  week: 'gggg[w]ww',\n  year: 'YYYY',\n  years: 'YYYY',\n  month: 'YYYY-MM',\n  months: 'YYYY-MM',\n  datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,\n  monthrange: 'YYYY-MM',\n  yearrange: 'YYYY',\n  daterange: DEFAULT_FORMATS_DATE,\n  datetimerange: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,\n}\n\nexport type TimeUnit = (typeof timeUnits)[number]\n"],"mappings":";AAGA,MAAa,YAAY;CAAC;CAAS;CAAW;CAAU;AAExD,MAAa,4BAA4B;AAEzC,MAAa,sCAAsC;AAEnD,MAAa,mCACX,OAAO,yBAAyB;AAElC,MAAa,uBAAuB;AAEpC,MAAa,uBAAuB;AAEpC,MAAa,6BAA6B;CACxC,MAAM;CACN,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;CACP,OAAO;CACP,QAAQ;CACR,UAAU,GAAG,qBAAqB,GAAG;CACrC,YAAY;CACZ,WAAW;CACX,WAAW;CACX,eAAe,GAAG,qBAAqB,GAAG;CAC3C"}

frontend/node_modules/element-plus/es/components/time-picker/src/props/basic-time-spinner.mjs

@@ -0,0 +1,28 @@
+import { buildProps, definePropType } from "../../../../utils/vue/props/runtime.mjs";
+import { disabledTimeListsProps } from "./shared.mjs";
+
+//#region ../../packages/components/time-picker/src/props/basic-time-spinner.ts
+const basicTimeSpinnerProps = buildProps({
+	role: {
+		type: String,
+		required: true
+	},
+	spinnerDate: {
+		type: definePropType(Object),
+		required: true
+	},
+	showSeconds: {
+		type: Boolean,
+		default: true
+	},
+	arrowControl: Boolean,
+	amPmMode: {
+		type: definePropType(String),
+		default: ""
+	},
+	...disabledTimeListsProps
+});
+
+//#endregion
+export { basicTimeSpinnerProps };
+//# sourceMappingURL=basic-time-spinner.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/props/basic-time-spinner.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-time-spinner.mjs","names":[],"sources":["../../../../../../../packages/components/time-picker/src/props/basic-time-spinner.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { disabledTimeListsProps } from '../props/shared'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const basicTimeSpinnerProps = buildProps({\n  role: {\n    type: String,\n    required: true,\n  },\n  spinnerDate: {\n    type: definePropType<Dayjs>(Object),\n    required: true,\n  },\n  showSeconds: {\n    type: Boolean,\n    default: true,\n  },\n  arrowControl: Boolean,\n  amPmMode: {\n    // 'a': am/pm; 'A': AM/PM\n    type: definePropType<'a' | 'A' | ''>(String),\n    default: '',\n  },\n  ...disabledTimeListsProps,\n} as const)\n\nexport type BasicTimeSpinnerProps = ExtractPropTypes<\n  typeof basicTimeSpinnerProps\n>\nexport type BasicTimeSpinnerPropsPublic = ExtractPublicPropTypes<\n  typeof basicTimeSpinnerProps\n>\n"],"mappings":";;;;AAMA,MAAa,wBAAwB,WAAW;CAC9C,MAAM;EACJ,MAAM;EACN,UAAU;EACX;CACD,aAAa;EACX,MAAM,eAAsB,OAAO;EACnC,UAAU;EACX;CACD,aAAa;EACX,MAAM;EACN,SAAS;EACV;CACD,cAAc;CACd,UAAU;EAER,MAAM,eAA+B,OAAO;EAC5C,SAAS;EACV;CACD,GAAG;CACJ,CAAU"}

frontend/node_modules/element-plus/es/components/time-picker/src/props/panel-time-picker.mjs

@@ -0,0 +1,13 @@
+import { buildProps, definePropType } from "../../../../utils/vue/props/runtime.mjs";
+import { timePanelSharedProps } from "./shared.mjs";
+
+//#region ../../packages/components/time-picker/src/props/panel-time-picker.ts
+const panelTimePickerProps = buildProps({
+	...timePanelSharedProps,
+	datetimeRole: String,
+	parsedValue: { type: definePropType(Object) }
+});
+
+//#endregion
+export { panelTimePickerProps };
+//# sourceMappingURL=panel-time-picker.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/props/panel-time-picker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-time-picker.mjs","names":[],"sources":["../../../../../../../packages/components/time-picker/src/props/panel-time-picker.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { timePanelSharedProps } from './shared'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const panelTimePickerProps = buildProps({\n  ...timePanelSharedProps,\n  datetimeRole: String,\n  parsedValue: {\n    type: definePropType<Dayjs>(Object),\n  },\n} as const)\n\nexport type PanelTimePickerProps = ExtractPropTypes<typeof panelTimePickerProps>\nexport type PanelTimePickerPropsPublic = ExtractPublicPropTypes<\n  typeof panelTimePickerProps\n>\n"],"mappings":";;;;AAMA,MAAa,uBAAuB,WAAW;CAC7C,GAAG;CACH,cAAc;CACd,aAAa,EACX,MAAM,eAAsB,OAAO,EACpC;CACF,CAAU"}

frontend/node_modules/element-plus/es/components/time-picker/src/props/panel-time-range.mjs

@@ -0,0 +1,12 @@
+import { buildProps, definePropType } from "../../../../utils/vue/props/runtime.mjs";
+import { timePanelSharedProps } from "./shared.mjs";
+
+//#region ../../packages/components/time-picker/src/props/panel-time-range.ts
+const panelTimeRangeProps = buildProps({
+	...timePanelSharedProps,
+	parsedValue: { type: definePropType(Array) }
+});
+
+//#endregion
+export { panelTimeRangeProps };
+//# sourceMappingURL=panel-time-range.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/props/panel-time-range.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-time-range.mjs","names":[],"sources":["../../../../../../../packages/components/time-picker/src/props/panel-time-range.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { timePanelSharedProps } from './shared'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const panelTimeRangeProps = buildProps({\n  ...timePanelSharedProps,\n  parsedValue: {\n    type: definePropType<[Dayjs, Dayjs]>(Array),\n  },\n} as const)\n\nexport type PanelTimeRangeProps = ExtractPropTypes<typeof panelTimeRangeProps>\nexport type PanelTimeRangePropsPublic = ExtractPublicPropTypes<\n  typeof panelTimeRangeProps\n>\n"],"mappings":";;;;AAMA,MAAa,sBAAsB,WAAW;CAC5C,GAAG;CACH,aAAa,EACX,MAAM,eAA+B,MAAM,EAC5C;CACF,CAAU"}

frontend/node_modules/element-plus/es/components/time-picker/src/props/shared.mjs

@@ -0,0 +1,23 @@
+import { buildProps, definePropType } from "../../../../utils/vue/props/runtime.mjs";
+
+//#region ../../packages/components/time-picker/src/props/shared.ts
+const disabledTimeListsProps = buildProps({
+	disabledHours: { type: definePropType(Function) },
+	disabledMinutes: { type: definePropType(Function) },
+	disabledSeconds: { type: definePropType(Function) }
+});
+const timePanelSharedProps = buildProps({
+	visible: Boolean,
+	actualVisible: {
+		type: Boolean,
+		default: void 0
+	},
+	format: {
+		type: String,
+		default: ""
+	}
+});
+
+//#endregion
+export { disabledTimeListsProps, timePanelSharedProps };
+//# sourceMappingURL=shared.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/props/shared.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.mjs","names":[],"sources":["../../../../../../../packages/components/time-picker/src/props/shared.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\n\nimport type { ExtractPropTypes, ExtractPublicPropTypes } from 'vue'\nimport type {\n  GetDisabledHours,\n  GetDisabledMinutes,\n  GetDisabledSeconds,\n} from '../common/props'\n\nexport const disabledTimeListsProps = buildProps({\n  /**\n   * @description To specify the array of hours that cannot be selected\n   */\n  disabledHours: {\n    type: definePropType<GetDisabledHours>(Function),\n  },\n  /**\n   * @description To specify the array of minutes that cannot be selected\n   */\n  disabledMinutes: {\n    type: definePropType<GetDisabledMinutes>(Function),\n  },\n  /**\n   * @description To specify the array of seconds that cannot be selected\n   */\n  disabledSeconds: {\n    type: definePropType<GetDisabledSeconds>(Function),\n  },\n} as const)\n\nexport type DisabledTimeListsProps = ExtractPropTypes<\n  typeof disabledTimeListsProps\n>\nexport type DisabledTimeListsPropsPublic = ExtractPublicPropTypes<\n  typeof disabledTimeListsProps\n>\n\nexport const timePanelSharedProps = buildProps({\n  visible: Boolean,\n  actualVisible: {\n    type: Boolean,\n    default: undefined,\n  },\n  format: {\n    type: String,\n    default: '',\n  },\n} as const)\n\nexport type TimePanelSharedProps = ExtractPropTypes<typeof timePanelSharedProps>\nexport type TimePanelSharedPropsPublic = ExtractPublicPropTypes<\n  typeof timePanelSharedProps\n>\n"],"mappings":";;;AASA,MAAa,yBAAyB,WAAW;CAI/C,eAAe,EACb,MAAM,eAAiC,SAAS,EACjD;CAID,iBAAiB,EACf,MAAM,eAAmC,SAAS,EACnD;CAID,iBAAiB,EACf,MAAM,eAAmC,SAAS,EACnD;CACF,CAAU;AASX,MAAa,uBAAuB,WAAW;CAC7C,SAAS;CACT,eAAe;EACb,MAAM;EACN,SAAS;EACV;CACD,QAAQ;EACN,MAAM;EACN,SAAS;EACV;CACF,CAAU"}

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker-com/basic-time-spinner.mjs

@@ -0,0 +1,8 @@
+import basic_time_spinner_vue_vue_type_script_setup_true_lang_default from "./basic-time-spinner.vue_vue_type_script_setup_true_lang.mjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/basic-time-spinner.vue
+var basic_time_spinner_default = basic_time_spinner_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { basic_time_spinner_default as default };
+//# sourceMappingURL=basic-time-spinner.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker-com/basic-time-spinner.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,284 @@
+import { CHANGE_EVENT } from "../../../../constants/event.mjs";
+import { isNumber } from "../../../../utils/types.mjs";
+import { rAF } from "../../../../utils/raf.mjs";
+import { getStyle } from "../../../../utils/dom/style.mjs";
+import { vRepeatClick } from "../../../../directives/repeat-click/index.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { ElIcon } from "../../../icon/index.mjs";
+import { ElScrollbar } from "../../../scrollbar/index.mjs";
+import { DEFAULT_FORMATS_TIME, PICKER_BASE_INJECTION_KEY, timeUnits } from "../constants.mjs";
+import { buildTimeList } from "../utils.mjs";
+import { getTimeLists } from "../composables/use-time-picker.mjs";
+import { basicTimeSpinnerProps } from "../props/basic-time-spinner.mjs";
+import { debounce } from "lodash-unified";
+import { ArrowDown, ArrowUp } from "@element-plus/icons-vue";
+import { Fragment, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createTextVNode, createVNode, defineComponent, inject, nextTick, normalizeClass, onMounted, openBlock, ref, renderList, toDisplayString, unref, watch, withCtx, withDirectives } from "vue";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/basic-time-spinner.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["onClick"];
+const _hoisted_2 = ["onMouseenter"];
+var basic_time_spinner_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "basic-time-spinner",
+	props: basicTimeSpinnerProps,
+	emits: [
+		CHANGE_EVENT,
+		"select-range",
+		"set-option"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const { isRange, format, saveOnBlur } = inject(PICKER_BASE_INJECTION_KEY).props;
+		const emit = __emit;
+		const ns = useNamespace("time");
+		const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
+		let isScrolling = false;
+		const ignoreScroll = {
+			hours: false,
+			minutes: false,
+			seconds: false
+		};
+		const currentScrollbar = ref();
+		const listRefsMap = {
+			hours: ref(),
+			minutes: ref(),
+			seconds: ref()
+		};
+		const spinnerItems = computed(() => {
+			return props.showSeconds ? timeUnits : timeUnits.slice(0, 2);
+		});
+		const timePartials = computed(() => {
+			const { spinnerDate } = props;
+			return {
+				hours: spinnerDate.hour(),
+				minutes: spinnerDate.minute(),
+				seconds: spinnerDate.second()
+			};
+		});
+		const timeList = computed(() => {
+			const { hours, minutes } = unref(timePartials);
+			const { role, spinnerDate } = props;
+			const compare = !isRange ? spinnerDate : void 0;
+			return {
+				hours: getHoursList(role, compare),
+				minutes: getMinutesList(hours, role, compare),
+				seconds: getSecondsList(hours, minutes, role, compare)
+			};
+		});
+		const arrowControlTimeList = computed(() => {
+			const { hours, minutes, seconds } = unref(timePartials);
+			return {
+				hours: buildTimeList(hours, 23),
+				minutes: buildTimeList(minutes, 59),
+				seconds: buildTimeList(seconds, 59)
+			};
+		});
+		const debouncedResetScroll = debounce((type) => {
+			isScrolling = false;
+			adjustCurrentSpinner(type);
+		}, 200);
+		const getAmPmFlag = (hour) => {
+			if (!!!props.amPmMode) return "";
+			const isCapital = props.amPmMode === "A";
+			let content = hour < 12 ? " am" : " pm";
+			if (isCapital) content = content.toUpperCase();
+			return content;
+		};
+		const emitSelectRange = (type) => {
+			let range = [0, 0];
+			const actualFormat = format || DEFAULT_FORMATS_TIME;
+			const hourIndex = actualFormat.indexOf("HH");
+			const minuteIndex = actualFormat.indexOf("mm");
+			const secondIndex = actualFormat.indexOf("ss");
+			switch (type) {
+				case "hours":
+					if (hourIndex !== -1) range = [hourIndex, hourIndex + 2];
+					break;
+				case "minutes":
+					if (minuteIndex !== -1) range = [minuteIndex, minuteIndex + 2];
+					break;
+				case "seconds":
+					if (secondIndex !== -1) range = [secondIndex, secondIndex + 2];
+					break;
+			}
+			const [left, right] = range;
+			emit("select-range", left, right);
+			currentScrollbar.value = type;
+		};
+		const adjustCurrentSpinner = (type) => {
+			adjustSpinner(type, unref(timePartials)[type]);
+		};
+		const adjustSpinners = () => {
+			adjustCurrentSpinner("hours");
+			adjustCurrentSpinner("minutes");
+			adjustCurrentSpinner("seconds");
+		};
+		const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
+		const adjustSpinner = (type, value) => {
+			if (props.arrowControl) return;
+			const scrollbar = unref(listRefsMap[type]);
+			if (scrollbar && scrollbar.$el) {
+				if (!saveOnBlur) {
+					ignoreScroll[type] = true;
+					rAF(() => {
+						ignoreScroll[type] = false;
+					});
+				}
+				getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type));
+			}
+		};
+		const typeItemHeight = (type) => {
+			const listItem = unref(listRefsMap[type])?.$el.querySelector("li");
+			if (listItem) return Number.parseFloat(getStyle(listItem, "height")) || 0;
+			return 0;
+		};
+		const onIncrement = () => {
+			scrollDown(1);
+		};
+		const onDecrement = () => {
+			scrollDown(-1);
+		};
+		const scrollDown = (step) => {
+			if (!currentScrollbar.value) emitSelectRange("hours");
+			const label = currentScrollbar.value;
+			const now = unref(timePartials)[label];
+			const next = findNextUnDisabled(label, now, step, currentScrollbar.value === "hours" ? 24 : 60);
+			modifyDateField(label, next);
+			adjustSpinner(label, next);
+			nextTick(() => emitSelectRange(label));
+		};
+		const findNextUnDisabled = (type, now, step, total) => {
+			let next = (now + step + total) % total;
+			const list = unref(timeList)[type];
+			while (list[next] && next !== now) next = (next + step + total) % total;
+			return next;
+		};
+		const modifyDateField = (type, value) => {
+			if (unref(timeList)[type][value]) return;
+			const { hours, minutes, seconds } = unref(timePartials);
+			let changeTo;
+			switch (type) {
+				case "hours":
+					changeTo = props.spinnerDate.hour(value).minute(minutes).second(seconds);
+					break;
+				case "minutes":
+					changeTo = props.spinnerDate.hour(hours).minute(value).second(seconds);
+					break;
+				case "seconds":
+					changeTo = props.spinnerDate.hour(hours).minute(minutes).second(value);
+					break;
+			}
+			emit(CHANGE_EVENT, changeTo);
+		};
+		const handleClick = (type, { value, disabled }) => {
+			if (!disabled) {
+				modifyDateField(type, value);
+				emitSelectRange(type);
+				adjustSpinner(type, value);
+			}
+		};
+		const handleScroll = (type) => {
+			if (!saveOnBlur && ignoreScroll[type]) return;
+			const scrollbar = unref(listRefsMap[type]);
+			if (!scrollbar) return;
+			isScrolling = true;
+			debouncedResetScroll(type);
+			modifyDateField(type, Math.min(Math.round((getScrollbarElement(scrollbar.$el).scrollTop - (scrollBarHeight(type) * .5 - 10) / typeItemHeight(type) + 3) / typeItemHeight(type)), type === "hours" ? 23 : 59));
+		};
+		const scrollBarHeight = (type) => {
+			return unref(listRefsMap[type]).$el.offsetHeight;
+		};
+		const bindScrollEvent = () => {
+			const bindFunction = (type) => {
+				const scrollbar = unref(listRefsMap[type]);
+				if (scrollbar && scrollbar.$el) getScrollbarElement(scrollbar.$el).onscroll = () => {
+					handleScroll(type);
+				};
+			};
+			bindFunction("hours");
+			bindFunction("minutes");
+			bindFunction("seconds");
+		};
+		onMounted(() => {
+			nextTick(() => {
+				!props.arrowControl && bindScrollEvent();
+				adjustSpinners();
+				if (props.role === "start") emitSelectRange("hours");
+			});
+		});
+		const setRef = (scrollbar, type) => {
+			listRefsMap[type].value = scrollbar ?? void 0;
+		};
+		emit("set-option", [`${props.role}_scrollDown`, scrollDown]);
+		emit("set-option", [`${props.role}_emitSelectRange`, emitSelectRange]);
+		watch(() => props.spinnerDate, () => {
+			if (isScrolling) return;
+			adjustSpinners();
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("div", { class: normalizeClass([unref(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }]) }, [!_ctx.arrowControl ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(spinnerItems.value, (item) => {
+				return openBlock(), createBlock(unref(ElScrollbar), {
+					key: item,
+					ref_for: true,
+					ref: (scrollbar) => setRef(scrollbar, item),
+					class: normalizeClass(unref(ns).be("spinner", "wrapper")),
+					"wrap-style": "max-height: inherit;",
+					"view-class": unref(ns).be("spinner", "list"),
+					noresize: "",
+					tag: "ul",
+					onMouseenter: ($event) => emitSelectRange(item),
+					onMousemove: ($event) => adjustCurrentSpinner(item)
+				}, {
+					default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(timeList.value[item], (disabled, key) => {
+						return openBlock(), createElementBlock("li", {
+							key,
+							class: normalizeClass([
+								unref(ns).be("spinner", "item"),
+								unref(ns).is("active", key === timePartials.value[item]),
+								unref(ns).is("disabled", disabled)
+							]),
+							onClick: ($event) => handleClick(item, {
+								value: key,
+								disabled
+							})
+						}, [item === "hours" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createTextVNode(toDisplayString(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + toDisplayString(getAmPmFlag(key)), 1)], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createTextVNode(toDisplayString(("0" + key).slice(-2)), 1)], 64))], 10, _hoisted_1);
+					}), 128))]),
+					_: 2
+				}, 1032, [
+					"class",
+					"view-class",
+					"onMouseenter",
+					"onMousemove"
+				]);
+			}), 128)) : createCommentVNode("v-if", true), _ctx.arrowControl ? (openBlock(true), createElementBlock(Fragment, { key: 1 }, renderList(spinnerItems.value, (item) => {
+				return openBlock(), createElementBlock("div", {
+					key: item,
+					class: normalizeClass([unref(ns).be("spinner", "wrapper"), unref(ns).is("arrow")]),
+					onMouseenter: ($event) => emitSelectRange(item)
+				}, [
+					withDirectives((openBlock(), createBlock(unref(ElIcon), { class: normalizeClass(["arrow-up", unref(ns).be("spinner", "arrow")]) }, {
+						default: withCtx(() => [createVNode(unref(ArrowUp))]),
+						_: 1
+					}, 8, ["class"])), [[unref(vRepeatClick), onDecrement]]),
+					withDirectives((openBlock(), createBlock(unref(ElIcon), { class: normalizeClass(["arrow-down", unref(ns).be("spinner", "arrow")]) }, {
+						default: withCtx(() => [createVNode(unref(ArrowDown))]),
+						_: 1
+					}, 8, ["class"])), [[unref(vRepeatClick), onIncrement]]),
+					createElementVNode("ul", { class: normalizeClass(unref(ns).be("spinner", "list")) }, [(openBlock(true), createElementBlock(Fragment, null, renderList(arrowControlTimeList.value[item], (time, key) => {
+						return openBlock(), createElementBlock("li", {
+							key,
+							class: normalizeClass([
+								unref(ns).be("spinner", "item"),
+								unref(ns).is("active", time === timePartials.value[item]),
+								unref(ns).is("disabled", timeList.value[item][time])
+							])
+						}, [unref(isNumber)(time) ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [item === "hours" ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [createTextVNode(toDisplayString(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + toDisplayString(getAmPmFlag(time)), 1)], 64)) : (openBlock(), createElementBlock(Fragment, { key: 1 }, [createTextVNode(toDisplayString(("0" + time).slice(-2)), 1)], 64))], 64)) : createCommentVNode("v-if", true)], 2);
+					}), 128))], 2)
+				], 42, _hoisted_2);
+			}), 128)) : createCommentVNode("v-if", true)], 2);
+		};
+	}
+});
+
+//#endregion
+export { basic_time_spinner_vue_vue_type_script_setup_true_lang_default as default };
+//# sourceMappingURL=basic-time-spinner.vue_vue_type_script_setup_true_lang.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.mjs

@@ -0,0 +1,8 @@
+import panel_time_pick_vue_vue_type_script_setup_true_lang_default from "./panel-time-pick.vue_vue_type_script_setup_true_lang.mjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-pick.vue
+var panel_time_pick_default = panel_time_pick_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { panel_time_pick_default as default };
+//# sourceMappingURL=panel-time-pick.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.vue.d.ts

@@ -0,0 +1,44 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.js";
+import "../../../../utils/index.js";
+import * as vue from "vue";
+import dayjs from "dayjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-pick.vue.d.ts
+declare const __VLS_export: vue.DefineComponent<vue.ExtractPropTypes<{
+  readonly datetimeRole: StringConstructor;
+  readonly parsedValue: {
+    readonly type: vue.PropType<dayjs.Dayjs>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly visible: BooleanConstructor;
+  readonly actualVisible: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  readonly format: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+}>, {}, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+  pick: (...args: any[]) => void;
+  "select-range": (...args: any[]) => void;
+  "set-picker-option": (...args: any[]) => void;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  readonly datetimeRole: StringConstructor;
+  readonly parsedValue: {
+    readonly type: vue.PropType<dayjs.Dayjs>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly visible: BooleanConstructor;
+  readonly actualVisible: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  readonly format: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+}>> & Readonly<{
+  onPick?: ((...args: any[]) => any) | undefined;
+  "onSelect-range"?: ((...args: any[]) => any) | undefined;
+  "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+}>, {
+  readonly visible: boolean;
+  readonly format: string;
+  readonly actualVisible: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { _default };

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-pick.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,174 @@
+import { EVENT_CODE } from "../../../../constants/aria.mjs";
+import { getEventCode } from "../../../../utils/dom/event.mjs";
+import { isUndefined } from "../../../../utils/types.mjs";
+import { useLocale } from "../../../../hooks/use-locale/index.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { PICKER_BASE_INJECTION_KEY } from "../constants.mjs";
+import { panelTimePickerProps } from "../props/panel-time-picker.mjs";
+import { useTimePanel } from "../composables/use-time-panel.mjs";
+import { buildAvailableTimeSlotGetter, useOldValue } from "../composables/use-time-picker.mjs";
+import basic_time_spinner_default from "./basic-time-spinner.mjs";
+import { Transition, computed, createBlock, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, inject, nextTick, normalizeClass, openBlock, ref, toDisplayString, unref, withCtx } from "vue";
+import dayjs from "dayjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-pick.vue?vue&type=script&setup=true&lang.ts
+var panel_time_pick_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "panel-time-pick",
+	props: panelTimePickerProps,
+	emits: [
+		"pick",
+		"select-range",
+		"set-picker-option"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
+		const { arrowControl, disabledHours, disabledMinutes, disabledSeconds, defaultValue } = pickerBase.props;
+		const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours, disabledMinutes, disabledSeconds);
+		const ns = useNamespace("time");
+		const { t, lang } = useLocale();
+		const selectionRange = ref([0, 2]);
+		const oldValue = useOldValue(props, {
+			modelValue: computed(() => pickerBase.props.modelValue),
+			valueOnClear: computed(() => pickerBase?.emptyValues ? pickerBase.emptyValues.valueOnClear.value : null)
+		});
+		const transitionName = computed(() => {
+			return isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
+		});
+		const showSeconds = computed(() => {
+			return props.format.includes("ss");
+		});
+		const amPmMode = computed(() => {
+			if (props.format.includes("A")) return "A";
+			if (props.format.includes("a")) return "a";
+			return "";
+		});
+		const isValidValue = (_date) => {
+			const parsedDate = dayjs(_date).locale(lang.value);
+			const result = getRangeAvailableTime(parsedDate);
+			return parsedDate.isSame(result);
+		};
+		const handleCancel = () => {
+			const old = oldValue.value;
+			emit("pick", old, false);
+			nextTick(() => {
+				oldValue.value = old;
+			});
+		};
+		const handleConfirm = (visible = false, first = false) => {
+			if (first) return;
+			emit("pick", props.parsedValue, visible);
+		};
+		const handleChange = (_date) => {
+			if (!props.visible) return;
+			emit("pick", getRangeAvailableTime(_date).millisecond(0), true);
+		};
+		const setSelectionRange = (start, end) => {
+			emit("select-range", start, end);
+			selectionRange.value = [start, end];
+		};
+		const changeSelectionRange = (step) => {
+			const actualFormat = props.format;
+			const hourIndex = actualFormat.indexOf("HH");
+			const minuteIndex = actualFormat.indexOf("mm");
+			const secondIndex = actualFormat.indexOf("ss");
+			const list = [];
+			const mapping = [];
+			if (hourIndex !== -1) {
+				list.push(hourIndex);
+				mapping.push("hours");
+			}
+			if (minuteIndex !== -1) {
+				list.push(minuteIndex);
+				mapping.push("minutes");
+			}
+			if (secondIndex !== -1 && showSeconds.value) {
+				list.push(secondIndex);
+				mapping.push("seconds");
+			}
+			const next = (list.indexOf(selectionRange.value[0]) + step + list.length) % list.length;
+			timePickerOptions["start_emitSelectRange"](mapping[next]);
+		};
+		const handleKeydown = (event) => {
+			const code = getEventCode(event);
+			const { left, right, up, down } = EVENT_CODE;
+			if ([left, right].includes(code)) {
+				changeSelectionRange(code === left ? -1 : 1);
+				event.preventDefault();
+				return;
+			}
+			if ([up, down].includes(code)) {
+				const step = code === up ? -1 : 1;
+				timePickerOptions["start_scrollDown"](step);
+				event.preventDefault();
+				return;
+			}
+		};
+		const { timePickerOptions, onSetOption, getAvailableTime } = useTimePanel({
+			getAvailableHours,
+			getAvailableMinutes,
+			getAvailableSeconds
+		});
+		const getRangeAvailableTime = (date) => {
+			return getAvailableTime(date, props.datetimeRole || "", true);
+		};
+		const parseUserInput = (value) => {
+			if (!value) return null;
+			return dayjs(value, props.format).locale(lang.value);
+		};
+		const getDefaultValue = () => {
+			return dayjs(defaultValue).locale(lang.value);
+		};
+		emit("set-picker-option", ["isValidValue", isValidValue]);
+		emit("set-picker-option", ["parseUserInput", parseUserInput]);
+		emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
+		emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
+		emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
+		emit("set-picker-option", ["handleCancel", handleCancel]);
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(Transition, { name: transitionName.value }, {
+				default: withCtx(() => [_ctx.actualVisible || _ctx.visible ? (openBlock(), createElementBlock("div", {
+					key: 0,
+					class: normalizeClass(unref(ns).b("panel"))
+				}, [createElementVNode("div", { class: normalizeClass([unref(ns).be("panel", "content"), { "has-seconds": showSeconds.value }]) }, [createVNode(basic_time_spinner_default, {
+					ref: "spinner",
+					role: _ctx.datetimeRole || "start",
+					"arrow-control": unref(arrowControl),
+					"show-seconds": showSeconds.value,
+					"am-pm-mode": amPmMode.value,
+					"spinner-date": _ctx.parsedValue,
+					"disabled-hours": unref(disabledHours),
+					"disabled-minutes": unref(disabledMinutes),
+					"disabled-seconds": unref(disabledSeconds),
+					onChange: handleChange,
+					onSetOption: unref(onSetOption),
+					onSelectRange: setSelectionRange
+				}, null, 8, [
+					"role",
+					"arrow-control",
+					"show-seconds",
+					"am-pm-mode",
+					"spinner-date",
+					"disabled-hours",
+					"disabled-minutes",
+					"disabled-seconds",
+					"onSetOption"
+				])], 2), createElementVNode("div", { class: normalizeClass(unref(ns).be("panel", "footer")) }, [createElementVNode("button", {
+					type: "button",
+					class: normalizeClass([unref(ns).be("panel", "btn"), "cancel"]),
+					onClick: handleCancel
+				}, toDisplayString(unref(t)("el.datepicker.cancel")), 3), createElementVNode("button", {
+					type: "button",
+					class: normalizeClass([unref(ns).be("panel", "btn"), "confirm"]),
+					onClick: _cache[0] || (_cache[0] = ($event) => handleConfirm())
+				}, toDisplayString(unref(t)("el.datepicker.confirm")), 3)], 2)], 2)) : createCommentVNode("v-if", true)]),
+				_: 1
+			}, 8, ["name"]);
+		};
+	}
+});
+
+//#endregion
+export { panel_time_pick_vue_vue_type_script_setup_true_lang_default as default };
+//# sourceMappingURL=panel-time-pick.vue_vue_type_script_setup_true_lang.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-range.mjs

@@ -0,0 +1,8 @@
+import panel_time_range_vue_vue_type_script_setup_true_lang_default from "./panel-time-range.vue_vue_type_script_setup_true_lang.mjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-range.vue
+var panel_time_range_default = panel_time_range_vue_vue_type_script_setup_true_lang_default;
+
+//#endregion
+export { panel_time_range_default as default };
+//# sourceMappingURL=panel-time-range.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker-com/panel-time-range.vue_vue_type_script_setup_true_lang.mjs

@@ -0,0 +1,245 @@
+import { EVENT_CODE } from "../../../../constants/aria.mjs";
+import { getEventCode } from "../../../../utils/dom/event.mjs";
+import { isArray } from "../../../../utils/types.mjs";
+import { useLocale } from "../../../../hooks/use-locale/index.mjs";
+import { useNamespace } from "../../../../hooks/use-namespace/index.mjs";
+import { PICKER_BASE_INJECTION_KEY } from "../constants.mjs";
+import { useTimePanel } from "../composables/use-time-panel.mjs";
+import { buildAvailableTimeSlotGetter, useOldValue } from "../composables/use-time-picker.mjs";
+import basic_time_spinner_default from "./basic-time-spinner.mjs";
+import { panelTimeRangeProps } from "../props/panel-time-range.mjs";
+import { union } from "lodash-unified";
+import { computed, createCommentVNode, createElementBlock, createElementVNode, createVNode, defineComponent, inject, nextTick, normalizeClass, openBlock, ref, toDisplayString, unref } from "vue";
+import dayjs from "dayjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-range.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = ["disabled"];
+var panel_time_range_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+	__name: "panel-time-range",
+	props: panelTimeRangeProps,
+	emits: [
+		"pick",
+		"select-range",
+		"set-picker-option"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const makeSelectRange = (start, end) => {
+			const result = [];
+			for (let i = start; i <= end; i++) result.push(i);
+			return result;
+		};
+		const { t, lang } = useLocale();
+		const nsTime = useNamespace("time");
+		const nsPicker = useNamespace("picker");
+		const pickerBase = inject(PICKER_BASE_INJECTION_KEY);
+		const { arrowControl, disabledHours, disabledMinutes, disabledSeconds, defaultValue } = pickerBase.props;
+		const startContainerKls = computed(() => [
+			nsTime.be("range-picker", "body"),
+			nsTime.be("panel", "content"),
+			nsTime.is("arrow", arrowControl),
+			showSeconds.value ? "has-seconds" : ""
+		]);
+		const endContainerKls = computed(() => [
+			nsTime.be("range-picker", "body"),
+			nsTime.be("panel", "content"),
+			nsTime.is("arrow", arrowControl),
+			showSeconds.value ? "has-seconds" : ""
+		]);
+		const startTime = computed(() => props.parsedValue[0]);
+		const endTime = computed(() => props.parsedValue[1]);
+		const oldValue = useOldValue(props, {
+			modelValue: computed(() => pickerBase.props.modelValue),
+			valueOnClear: computed(() => pickerBase?.emptyValues ? pickerBase.emptyValues.valueOnClear.value : null)
+		});
+		const handleCancel = () => {
+			const old = oldValue.value;
+			emit("pick", old, false);
+			nextTick(() => {
+				oldValue.value = old;
+			});
+		};
+		const showSeconds = computed(() => {
+			return props.format.includes("ss");
+		});
+		const amPmMode = computed(() => {
+			if (props.format.includes("A")) return "A";
+			if (props.format.includes("a")) return "a";
+			return "";
+		});
+		const handleConfirm = (visible = false) => {
+			emit("pick", [startTime.value, endTime.value], visible);
+		};
+		const handleMinChange = (date) => {
+			handleChange(date.millisecond(0), endTime.value);
+		};
+		const handleMaxChange = (date) => {
+			handleChange(startTime.value, date.millisecond(0));
+		};
+		const isValidValue = (_date) => {
+			const parsedDate = _date.map((_) => dayjs(_).locale(lang.value));
+			const result = getRangeAvailableTime(parsedDate);
+			return parsedDate[0].isSame(result[0]) && parsedDate[1].isSame(result[1]);
+		};
+		const handleChange = (start, end) => {
+			if (!props.visible) return;
+			emit("pick", [start, end], true);
+		};
+		const btnConfirmDisabled = computed(() => {
+			return startTime.value > endTime.value;
+		});
+		const selectionRange = ref([0, 2]);
+		const setMinSelectionRange = (start, end) => {
+			emit("select-range", start, end, "min");
+			selectionRange.value = [start, end];
+		};
+		const offset = computed(() => showSeconds.value ? 11 : 8);
+		const setMaxSelectionRange = (start, end) => {
+			emit("select-range", start, end, "max");
+			const _offset = unref(offset);
+			selectionRange.value = [start + _offset, end + _offset];
+		};
+		const changeSelectionRange = (step) => {
+			const list = showSeconds.value ? [
+				0,
+				3,
+				6,
+				11,
+				14,
+				17
+			] : [
+				0,
+				3,
+				8,
+				11
+			];
+			const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
+			const next = (list.indexOf(selectionRange.value[0]) + step + list.length) % list.length;
+			const half = list.length / 2;
+			if (next < half) timePickerOptions["start_emitSelectRange"](mapping[next]);
+			else timePickerOptions["end_emitSelectRange"](mapping[next - half]);
+		};
+		const handleKeydown = (event) => {
+			const code = getEventCode(event);
+			const { left, right, up, down } = EVENT_CODE;
+			if ([left, right].includes(code)) {
+				changeSelectionRange(code === left ? -1 : 1);
+				event.preventDefault();
+				return;
+			}
+			if ([up, down].includes(code)) {
+				const step = code === up ? -1 : 1;
+				timePickerOptions[`${selectionRange.value[0] < offset.value ? "start" : "end"}_scrollDown`](step);
+				event.preventDefault();
+				return;
+			}
+		};
+		const disabledHours_ = (role, compare) => {
+			const defaultDisable = disabledHours ? disabledHours(role) : [];
+			const isStart = role === "start";
+			const compareHour = (compare || (isStart ? endTime.value : startTime.value)).hour();
+			return union(defaultDisable, isStart ? makeSelectRange(compareHour + 1, 23) : makeSelectRange(0, compareHour - 1));
+		};
+		const disabledMinutes_ = (hour, role, compare) => {
+			const defaultDisable = disabledMinutes ? disabledMinutes(hour, role) : [];
+			const isStart = role === "start";
+			const compareDate = compare || (isStart ? endTime.value : startTime.value);
+			if (hour !== compareDate.hour()) return defaultDisable;
+			const compareMinute = compareDate.minute();
+			return union(defaultDisable, isStart ? makeSelectRange(compareMinute + 1, 59) : makeSelectRange(0, compareMinute - 1));
+		};
+		const disabledSeconds_ = (hour, minute, role, compare) => {
+			const defaultDisable = disabledSeconds ? disabledSeconds(hour, minute, role) : [];
+			const isStart = role === "start";
+			const compareDate = compare || (isStart ? endTime.value : startTime.value);
+			const compareHour = compareDate.hour();
+			const compareMinute = compareDate.minute();
+			if (hour !== compareHour || minute !== compareMinute) return defaultDisable;
+			const compareSecond = compareDate.second();
+			return union(defaultDisable, isStart ? makeSelectRange(compareSecond + 1, 59) : makeSelectRange(0, compareSecond - 1));
+		};
+		const getRangeAvailableTime = ([start, end]) => {
+			return [getAvailableTime(start, "start", true, end), getAvailableTime(end, "end", false, start)];
+		};
+		const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours_, disabledMinutes_, disabledSeconds_);
+		const { timePickerOptions, getAvailableTime, onSetOption } = useTimePanel({
+			getAvailableHours,
+			getAvailableMinutes,
+			getAvailableSeconds
+		});
+		const parseUserInput = (days) => {
+			if (!days) return null;
+			if (isArray(days)) return days.map((d) => dayjs(d, props.format).locale(lang.value));
+			return dayjs(days, props.format).locale(lang.value);
+		};
+		const getDefaultValue = () => {
+			if (isArray(defaultValue)) return defaultValue.map((d) => dayjs(d).locale(lang.value));
+			const defaultDay = dayjs(defaultValue).locale(lang.value);
+			return [defaultDay, defaultDay.add(60, "m")];
+		};
+		emit("set-picker-option", ["parseUserInput", parseUserInput]);
+		emit("set-picker-option", ["isValidValue", isValidValue]);
+		emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
+		emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
+		emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
+		emit("set-picker-option", ["handleCancel", handleCancel]);
+		return (_ctx, _cache) => {
+			return _ctx.actualVisible ? (openBlock(), createElementBlock("div", {
+				key: 0,
+				class: normalizeClass([unref(nsTime).b("range-picker"), unref(nsPicker).b("panel")])
+			}, [createElementVNode("div", { class: normalizeClass(unref(nsTime).be("range-picker", "content")) }, [createElementVNode("div", { class: normalizeClass(unref(nsTime).be("range-picker", "cell")) }, [createElementVNode("div", { class: normalizeClass(unref(nsTime).be("range-picker", "header")) }, toDisplayString(unref(t)("el.datepicker.startTime")), 3), createElementVNode("div", { class: normalizeClass(startContainerKls.value) }, [createVNode(basic_time_spinner_default, {
+				ref: "minSpinner",
+				role: "start",
+				"show-seconds": showSeconds.value,
+				"am-pm-mode": amPmMode.value,
+				"arrow-control": unref(arrowControl),
+				"spinner-date": startTime.value,
+				"disabled-hours": disabledHours_,
+				"disabled-minutes": disabledMinutes_,
+				"disabled-seconds": disabledSeconds_,
+				onChange: handleMinChange,
+				onSetOption: unref(onSetOption),
+				onSelectRange: setMinSelectionRange
+			}, null, 8, [
+				"show-seconds",
+				"am-pm-mode",
+				"arrow-control",
+				"spinner-date",
+				"onSetOption"
+			])], 2)], 2), createElementVNode("div", { class: normalizeClass(unref(nsTime).be("range-picker", "cell")) }, [createElementVNode("div", { class: normalizeClass(unref(nsTime).be("range-picker", "header")) }, toDisplayString(unref(t)("el.datepicker.endTime")), 3), createElementVNode("div", { class: normalizeClass(endContainerKls.value) }, [createVNode(basic_time_spinner_default, {
+				ref: "maxSpinner",
+				role: "end",
+				"show-seconds": showSeconds.value,
+				"am-pm-mode": amPmMode.value,
+				"arrow-control": unref(arrowControl),
+				"spinner-date": endTime.value,
+				"disabled-hours": disabledHours_,
+				"disabled-minutes": disabledMinutes_,
+				"disabled-seconds": disabledSeconds_,
+				onChange: handleMaxChange,
+				onSetOption: unref(onSetOption),
+				onSelectRange: setMaxSelectionRange
+			}, null, 8, [
+				"show-seconds",
+				"am-pm-mode",
+				"arrow-control",
+				"spinner-date",
+				"onSetOption"
+			])], 2)], 2)], 2), createElementVNode("div", { class: normalizeClass(unref(nsTime).be("panel", "footer")) }, [createElementVNode("button", {
+				type: "button",
+				class: normalizeClass([unref(nsTime).be("panel", "btn"), "cancel"]),
+				onClick: _cache[0] || (_cache[0] = ($event) => handleCancel())
+			}, toDisplayString(unref(t)("el.datepicker.cancel")), 3), createElementVNode("button", {
+				type: "button",
+				class: normalizeClass([unref(nsTime).be("panel", "btn"), "confirm"]),
+				disabled: btnConfirmDisabled.value,
+				onClick: _cache[1] || (_cache[1] = ($event) => handleConfirm())
+			}, toDisplayString(unref(t)("el.datepicker.confirm")), 11, _hoisted_1)], 2)], 2)) : createCommentVNode("v-if", true);
+		};
+	}
+});
+
+//#endregion
+export { panel_time_range_vue_vue_type_script_setup_true_lang_default as default };
+//# sourceMappingURL=panel-time-range.vue_vue_type_script_setup_true_lang.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker.d.ts

@@ -0,0 +1,453 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../utils/vue/props/types.js";
+import "../../../utils/index.js";
+import { GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds, ModelValueType, SingleOrRange } from "./common/props.js";
+import "../../../index.js";
+import { Options, Placement } from "../../popper/index.js";
+import * as vue from "vue";
+import * as vue_jsx_runtime0 from "vue/jsx-runtime";
+
+//#region ../../packages/components/time-picker/src/time-picker.d.ts
+declare const _default: vue.DefineComponent<vue.ExtractPropTypes<{
+  /**
+   * @description whether to pick a time range
+   */
+  isRange: BooleanConstructor;
+  showNow: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  showConfirm: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  showFooter: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  showWeekNumber: BooleanConstructor;
+  ariaLabel: StringConstructor;
+  emptyValues: ArrayConstructor;
+  valueOnClear: EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+  disabledDate: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  cellClassName: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  shortcuts: EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+  arrowControl: BooleanConstructor;
+  tabindex: EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+  validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  unlinkPanels: BooleanConstructor;
+  placement: EpPropFinalized<(new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | (((new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement)) | null)[], Placement, unknown, "bottom", boolean>;
+  fallbackPlacements: EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
+  disabledHours: {
+    readonly type: vue.PropType<GetDisabledHours>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  disabledMinutes: {
+    readonly type: vue.PropType<GetDisabledMinutes>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  disabledSeconds: {
+    readonly type: vue.PropType<GetDisabledSeconds>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  automaticDropdown: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  id: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  name: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  popperClass: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  popperStyle: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue) | (((new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  format: StringConstructor;
+  valueFormat: StringConstructor;
+  dateFormat: StringConstructor;
+  timeFormat: StringConstructor;
+  type: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  clearIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, boolean>;
+  editable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  saveOnBlur: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  prefixIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, "", boolean>;
+  size: {
+    readonly type: vue.PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly: BooleanConstructor;
+  disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  placeholder: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  popperOptions: EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+  modelValue: EpPropFinalized<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null)) | null)[], unknown, unknown, "", boolean>;
+  rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
+  startPlaceholder: StringConstructor;
+  endPlaceholder: StringConstructor;
+  defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  defaultTime: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>, () => vue_jsx_runtime0.JSX.Element, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+  /**
+   * @description whether to pick a time range
+   */
+  isRange: BooleanConstructor;
+  showNow: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  showConfirm: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  showFooter: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  showWeekNumber: BooleanConstructor;
+  ariaLabel: StringConstructor;
+  emptyValues: ArrayConstructor;
+  valueOnClear: EpPropFinalized<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown, undefined, boolean>;
+  disabledDate: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  cellClassName: {
+    readonly type: vue.PropType<Function>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  shortcuts: EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+  arrowControl: BooleanConstructor;
+  tabindex: EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+  validateEvent: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  unlinkPanels: BooleanConstructor;
+  placement: EpPropFinalized<(new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | (((new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement)) | null)[], Placement, unknown, "bottom", boolean>;
+  fallbackPlacements: EpPropFinalized<(new (...args: any[]) => Placement[]) | (() => Placement[]) | (((new (...args: any[]) => Placement[]) | (() => Placement[])) | null)[], unknown, unknown, readonly ["bottom", "top", "right", "left"], boolean>;
+  disabledHours: {
+    readonly type: vue.PropType<GetDisabledHours>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  disabledMinutes: {
+    readonly type: vue.PropType<GetDisabledMinutes>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  disabledSeconds: {
+    readonly type: vue.PropType<GetDisabledSeconds>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  automaticDropdown: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  id: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  name: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>) | (((new (...args: any[]) => string | [string, string]) | (() => SingleOrRange<string>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  popperClass: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | (string | {
+      [x: string]: boolean;
+    } | any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  popperStyle: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue) | (((new (...args: any[]) => string | false | vue.CSSProperties | vue.StyleValue[]) | (() => vue.StyleValue)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  format: StringConstructor;
+  valueFormat: StringConstructor;
+  dateFormat: StringConstructor;
+  timeFormat: StringConstructor;
+  type: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  clearable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  clearIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, vue.DefineComponent<{}, void, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>, boolean>;
+  editable: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  saveOnBlur: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  prefixIcon: EpPropFinalized<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown, "", boolean>;
+  size: {
+    readonly type: vue.PropType<EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly: BooleanConstructor;
+  disabled: EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+  placeholder: EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+  popperOptions: EpPropFinalized<(new (...args: any[]) => Partial<Options>) | (() => Partial<Options>) | (((new (...args: any[]) => Partial<Options>) | (() => Partial<Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+  modelValue: EpPropFinalized<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null)) | null)[], unknown, unknown, "", boolean>;
+  rangeSeparator: EpPropFinalized<StringConstructor, unknown, unknown, "-", boolean>;
+  startPlaceholder: StringConstructor;
+  endPlaceholder: StringConstructor;
+  defaultValue: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  defaultTime: {
+    readonly type: vue.PropType<EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | (((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>)) | null)[], unknown, unknown>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+}>> & Readonly<{
+  "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+  type: string;
+  disabled: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  modelValue: EpPropMergeType<(new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null) | (((new (...args: any[]) => string | number | string[] | Date | number[] | Date[]) | (() => ModelValueType | null)) | null)[], unknown, unknown>;
+  placeholder: string;
+  readonly: boolean;
+  clearable: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  clearIcon: EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown>;
+  prefixIcon: EpPropMergeType<(new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component) | (((new (...args: any[]) => (string | vue.Component) & {}) | (() => string | vue.Component)) | null)[], unknown, unknown>;
+  tabindex: EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+  validateEvent: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  fallbackPlacements: Placement[];
+  placement: EpPropMergeType<(new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement) | (((new (...args: any[]) => "top" | "auto" | "bottom" | "left" | "right" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => Placement)) | null)[], Placement, unknown>;
+  popperOptions: Partial<Options>;
+  valueOnClear: EpPropMergeType<(new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null) | (((new (...args: any[]) => string | number | boolean | Function) | (() => string | number | boolean | Function | null)) | null)[], unknown, unknown>;
+  automaticDropdown: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  editable: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  saveOnBlur: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  rangeSeparator: string;
+  shortcuts: unknown[];
+  showNow: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  showConfirm: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  showFooter: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  showWeekNumber: boolean;
+  arrowControl: boolean;
+  unlinkPanels: boolean;
+  isRange: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { _default };

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker.mjs

@@ -0,0 +1,54 @@
+import { UPDATE_MODEL_EVENT } from "../../../constants/event.mjs";
+import { DEFAULT_FORMATS_TIME, PICKER_POPPER_OPTIONS_INJECTION_KEY } from "./constants.mjs";
+import { timePickerDefaultProps } from "./common/props.mjs";
+import picker_default from "./common/picker.mjs";
+import panel_time_pick_default from "./time-picker-com/panel-time-pick.mjs";
+import panel_time_range_default from "./time-picker-com/panel-time-range.mjs";
+import { createVNode, defineComponent, mergeProps, provide, ref } from "vue";
+import dayjs from "dayjs";
+import customParseFormat from "dayjs/plugin/customParseFormat.js";
+
+//#region ../../packages/components/time-picker/src/time-picker.tsx
+dayjs.extend(customParseFormat);
+var time_picker_default = /* @__PURE__ */ defineComponent({
+	name: "ElTimePicker",
+	install: null,
+	props: {
+		...timePickerDefaultProps,
+		isRange: Boolean
+	},
+	emits: [UPDATE_MODEL_EVENT],
+	setup(props, ctx) {
+		const commonPicker = ref();
+		const [type, Panel] = props.isRange ? ["timerange", panel_time_range_default] : ["time", panel_time_pick_default];
+		const modelUpdater = (value) => ctx.emit(UPDATE_MODEL_EVENT, value);
+		provide(PICKER_POPPER_OPTIONS_INJECTION_KEY, props.popperOptions);
+		ctx.expose({
+			focus: () => {
+				commonPicker.value?.focus();
+			},
+			blur: () => {
+				commonPicker.value?.blur();
+			},
+			handleOpen: () => {
+				commonPicker.value?.handleOpen();
+			},
+			handleClose: () => {
+				commonPicker.value?.handleClose();
+			}
+		});
+		return () => {
+			const format = props.format ?? DEFAULT_FORMATS_TIME;
+			return createVNode(picker_default, mergeProps(props, {
+				"ref": commonPicker,
+				"type": type,
+				"format": format,
+				"onUpdate:modelValue": modelUpdater
+			}), { default: (props) => createVNode(Panel, props, null) });
+		};
+	}
+});
+
+//#endregion
+export { time_picker_default as default };
+//# sourceMappingURL=time-picker.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/time-picker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-picker.mjs","names":["defineComponent","provide","ref","createVNode","_createVNode","mergeProps","_mergeProps","dayjs","customParseFormat","UPDATE_MODEL_EVENT","DEFAULT_FORMATS_TIME","PICKER_POPPER_OPTIONS_INJECTION_KEY","Picker","TimePickPanel","TimeRangePanel","timePickerDefaultProps","extend","name","install","props","isRange","Boolean","emits","setup","ctx","commonPicker","type","Panel","modelUpdater","value","emit","popperOptions","expose","focus","blur","handleOpen","handleClose","format","default"],"sources":["../../../../../../packages/components/time-picker/src/time-picker.tsx"],"sourcesContent":["import { defineComponent, provide, ref } from 'vue'\nimport dayjs from 'dayjs'\nimport customParseFormat from 'dayjs/plugin/customParseFormat.js'\nimport { UPDATE_MODEL_EVENT } from '@element-plus/constants'\nimport {\n  DEFAULT_FORMATS_TIME,\n  PICKER_POPPER_OPTIONS_INJECTION_KEY,\n} from './constants'\nimport Picker from './common/picker.vue'\nimport TimePickPanel from './time-picker-com/panel-time-pick.vue'\nimport TimeRangePanel from './time-picker-com/panel-time-range.vue'\nimport { timePickerDefaultProps } from './common/props'\n\ndayjs.extend(customParseFormat)\n\nexport default defineComponent({\n  name: 'ElTimePicker',\n  install: null,\n  props: {\n    ...timePickerDefaultProps,\n    /**\n     * @description whether to pick a time range\n     */\n    isRange: Boolean,\n  },\n  emits: [UPDATE_MODEL_EVENT],\n  setup(props, ctx) {\n    const commonPicker = ref<InstanceType<typeof Picker>>()\n    const [type, Panel] = props.isRange\n      ? ['timerange', TimeRangePanel]\n      : ['time', TimePickPanel]\n\n    const modelUpdater = (value: any) => ctx.emit(UPDATE_MODEL_EVENT, value)\n    provide(PICKER_POPPER_OPTIONS_INJECTION_KEY, props.popperOptions)\n    ctx.expose({\n      /**\n       * @description focus the Input component\n       */\n      focus: () => {\n        commonPicker.value?.focus()\n      },\n      /**\n       * @description blur the Input component\n       */\n      blur: () => {\n        commonPicker.value?.blur()\n      },\n      /**\n       * @description open the TimePicker popper\n       */\n      handleOpen: () => {\n        commonPicker.value?.handleOpen()\n      },\n      /**\n       * @description close the TimePicker popper\n       */\n      handleClose: () => {\n        commonPicker.value?.handleClose()\n      },\n    })\n\n    return () => {\n      const format = props.format ?? DEFAULT_FORMATS_TIME\n\n      return (\n        <Picker\n          {...props}\n          ref={commonPicker}\n          type={type}\n          format={format}\n          onUpdate:modelValue={modelUpdater}\n        >\n          {{\n            default: (props: any) => <Panel {...props} />,\n          }}\n        </Picker>\n      )\n    }\n  },\n})\n"],"mappings":";;;;;;;;;;;AAaAO,MAAMS,OAAOR,kBAAkB;AAE/B,0BAAeR,gCAAgB;CAC7BiB,MAAM;CACNC,SAAS;CACTC,OAAO;EACL,GAAGJ;EAIHK,SAASC;EACV;CACDC,OAAO,CAACb,mBAAmB;CAC3Bc,MAAMJ,OAAOK,KAAK;EAChB,MAAMC,eAAevB,KAAkC;EACvD,MAAM,CAACwB,MAAMC,SAASR,MAAMC,UACxB,CAAC,aAAaN,yBAAe,GAC7B,CAAC,QAAQD,wBAAc;EAE3B,MAAMe,gBAAgBC,UAAeL,IAAIM,KAAKrB,oBAAoBoB,MAAM;AACxE5B,UAAQU,qCAAqCQ,MAAMY,cAAc;AACjEP,MAAIQ,OAAO;GAITC,aAAa;AACXR,iBAAaI,OAAOI,OAAO;;GAK7BC,YAAY;AACVT,iBAAaI,OAAOK,MAAM;;GAK5BC,kBAAkB;AAChBV,iBAAaI,OAAOM,YAAY;;GAKlCC,mBAAmB;AACjBX,iBAAaI,OAAOO,aAAa;;GAEpC,CAAC;AAEF,eAAa;GACX,MAAMC,SAASlB,MAAMkB,UAAU3B;AAE/B,UAAAN,YAAAQ,gBAAAN,WAEQa,OAAK;IAAA,OACJM;IAAY,QACXC;IAAI,UACFW;IAAM,uBACOT;IAAY,CAAA,EAAA,EAG/BU,UAAUnB,UAAUf,YAAAuB,OAAgBR,OAAK,KAAA,EAAI,CAAA;;;CAMxD,CAAC"}

frontend/node_modules/element-plus/es/components/time-picker/src/utils.d.ts

@@ -0,0 +1,17 @@
+import { DateOrDates, DayOrDays } from "./common/props.js";
+import dayjs, { Dayjs } from "dayjs";
+
+//#region ../../packages/components/time-picker/src/utils.d.ts
+type TimeList = [number | undefined, number, undefined | number];
+declare const buildTimeList: (value: number, bound: number) => TimeList;
+declare const rangeArr: (n: number) => number[];
+declare const extractDateFormat: (format: string) => string;
+declare const extractTimeFormat: (format: string) => string;
+declare const dateEquals: (a: Date | unknown, b: Date | unknown) => boolean;
+declare const valueEquals: (a: Array<Date> | unknown, b: Array<Date> | unknown) => boolean;
+declare const parseDate: (date: string | number | Date, format: string | undefined, lang: string) => dayjs.Dayjs | undefined;
+declare const formatter: (date: string | number | Date | Dayjs, format: string | undefined, lang: string) => string | number | Date | dayjs.Dayjs;
+declare const makeList: (total: number, method?: () => number[]) => boolean[];
+declare const dayOrDaysToDate: (dayOrDays: DayOrDays) => DateOrDates;
+//#endregion
+export { TimeList, buildTimeList, dateEquals, dayOrDaysToDate, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, valueEquals };

frontend/node_modules/element-plus/es/components/time-picker/src/utils.mjs

@@ -0,0 +1,57 @@
+import { isArray, isDate, isEmpty } from "../../../utils/types.mjs";
+import dayjs from "dayjs";
+
+//#region ../../packages/components/time-picker/src/utils.ts
+const buildTimeList = (value, bound) => {
+	return [
+		value > 0 ? value - 1 : void 0,
+		value,
+		value < bound ? value + 1 : void 0
+	];
+};
+const rangeArr = (n) => Array.from(Array.from({ length: n }).keys());
+const extractDateFormat = (format) => {
+	return format.replace(/\W?m{1,2}|\W?ZZ/g, "").replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, "").trim();
+};
+const extractTimeFormat = (format) => {
+	return format.replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, "").trim();
+};
+const dateEquals = function(a, b) {
+	const aIsDate = isDate(a);
+	const bIsDate = isDate(b);
+	if (aIsDate && bIsDate) return a.getTime() === b.getTime();
+	if (!aIsDate && !bIsDate) return a === b;
+	return false;
+};
+const valueEquals = function(a, b) {
+	const aIsArray = isArray(a);
+	const bIsArray = isArray(b);
+	if (aIsArray && bIsArray) {
+		if (a.length !== b.length) return false;
+		return a.every((item, index) => dateEquals(item, b[index]));
+	}
+	if (!aIsArray && !bIsArray) return dateEquals(a, b);
+	return false;
+};
+const parseDate = function(date, format, lang) {
+	const day = isEmpty(format) || format === "x" ? dayjs(date).locale(lang) : dayjs(date, format).locale(lang);
+	return day.isValid() ? day : void 0;
+};
+const formatter = function(date, format, lang) {
+	if (isEmpty(format)) return date;
+	if (format === "x") return +date;
+	return dayjs(date).locale(lang).format(format);
+};
+const makeList = (total, method) => {
+	const arr = [];
+	const disabledArr = method?.();
+	for (let i = 0; i < total; i++) arr.push(disabledArr?.includes(i) ?? false);
+	return arr;
+};
+const dayOrDaysToDate = (dayOrDays) => {
+	return isArray(dayOrDays) ? dayOrDays.map((d) => d.toDate()) : dayOrDays.toDate();
+};
+
+//#endregion
+export { buildTimeList, dateEquals, dayOrDaysToDate, extractDateFormat, extractTimeFormat, formatter, makeList, parseDate, rangeArr, valueEquals };
+//# sourceMappingURL=utils.mjs.map

frontend/node_modules/element-plus/es/components/time-picker/src/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../../../packages/components/time-picker/src/utils.ts"],"sourcesContent":["import dayjs from 'dayjs'\nimport { isArray, isDate, isEmpty } from '@element-plus/utils'\n\nimport type { Dayjs } from 'dayjs'\nimport type { DateOrDates, DayOrDays } from './common/props'\n\nexport type TimeList = [number | undefined, number, undefined | number]\n\nexport const buildTimeList = (value: number, bound: number): TimeList => {\n  return [\n    value > 0 ? value - 1 : undefined,\n    value,\n    value < bound ? value + 1 : undefined,\n  ]\n}\n\nexport const rangeArr = (n: number) =>\n  Array.from(Array.from({ length: n }).keys())\n\nexport const extractDateFormat = (format: string) => {\n  return format\n    .replace(/\\W?m{1,2}|\\W?ZZ/g, '')\n    .replace(/\\W?h{1,2}|\\W?s{1,3}|\\W?a/gi, '')\n    .trim()\n}\n\nexport const extractTimeFormat = (format: string) => {\n  return format\n    .replace(/\\W?D{1,2}|\\W?Do|\\W?d{1,4}|\\W?M{1,4}|\\W?Y{2,4}/g, '')\n    .trim()\n}\n\nexport const dateEquals = function (a: Date | unknown, b: Date | unknown) {\n  const aIsDate = isDate(a)\n  const bIsDate = isDate(b)\n  if (aIsDate && bIsDate) {\n    return a.getTime() === b.getTime()\n  }\n  if (!aIsDate && !bIsDate) {\n    return a === b\n  }\n  return false\n}\n\nexport const valueEquals = function (\n  a: Array<Date> | unknown,\n  b: Array<Date> | unknown\n) {\n  const aIsArray = isArray(a)\n  const bIsArray = isArray(b)\n  if (aIsArray && bIsArray) {\n    if (a.length !== b.length) {\n      return false\n    }\n    return a.every((item, index) => dateEquals(item, b[index]))\n  }\n  if (!aIsArray && !bIsArray) {\n    return dateEquals(a, b)\n  }\n  return false\n}\n\nexport const parseDate = function (\n  date: string | number | Date,\n  format: string | undefined,\n  lang: string\n) {\n  const day =\n    isEmpty(format) || format === 'x'\n      ? dayjs(date).locale(lang)\n      : dayjs(date, format).locale(lang)\n  return day.isValid() ? day : undefined\n}\n\nexport const formatter = function (\n  date: string | number | Date | Dayjs,\n  format: string | undefined,\n  lang: string\n) {\n  if (isEmpty(format)) return date\n  if (format === 'x') return +date\n  return dayjs(date).locale(lang).format(format)\n}\n\nexport const makeList = (total: number, method?: () => number[]) => {\n  const arr: boolean[] = []\n  const disabledArr = method?.()\n  for (let i = 0; i < total; i++) {\n    arr.push(disabledArr?.includes(i) ?? false)\n  }\n  return arr\n}\n\nexport const dayOrDaysToDate = (dayOrDays: DayOrDays): DateOrDates => {\n  return isArray(dayOrDays)\n    ? (dayOrDays.map((d) => d.toDate()) as [Date, Date])\n    : dayOrDays.toDate()\n}\n"],"mappings":";;;;AAQA,MAAa,iBAAiB,OAAe,UAA4B;AACvE,QAAO;EACL,QAAQ,IAAI,QAAQ,IAAI;EACxB;EACA,QAAQ,QAAQ,QAAQ,IAAI;EAC7B;;AAGH,MAAa,YAAY,MACvB,MAAM,KAAK,MAAM,KAAK,EAAE,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC;AAE9C,MAAa,qBAAqB,WAAmB;AACnD,QAAO,OACJ,QAAQ,oBAAoB,GAAG,CAC/B,QAAQ,8BAA8B,GAAG,CACzC,MAAM;;AAGX,MAAa,qBAAqB,WAAmB;AACnD,QAAO,OACJ,QAAQ,kDAAkD,GAAG,CAC7D,MAAM;;AAGX,MAAa,aAAa,SAAU,GAAmB,GAAmB;CACxE,MAAM,UAAU,OAAO,EAAE;CACzB,MAAM,UAAU,OAAO,EAAE;AACzB,KAAI,WAAW,QACb,QAAO,EAAE,SAAS,KAAK,EAAE,SAAS;AAEpC,KAAI,CAAC,WAAW,CAAC,QACf,QAAO,MAAM;AAEf,QAAO;;AAGT,MAAa,cAAc,SACzB,GACA,GACA;CACA,MAAM,WAAW,QAAQ,EAAE;CAC3B,MAAM,WAAW,QAAQ,EAAE;AAC3B,KAAI,YAAY,UAAU;AACxB,MAAI,EAAE,WAAW,EAAE,OACjB,QAAO;AAET,SAAO,EAAE,OAAO,MAAM,UAAU,WAAW,MAAM,EAAE,OAAO,CAAC;;AAE7D,KAAI,CAAC,YAAY,CAAC,SAChB,QAAO,WAAW,GAAG,EAAE;AAEzB,QAAO;;AAGT,MAAa,YAAY,SACvB,MACA,QACA,MACA;CACA,MAAM,MACJ,QAAQ,OAAO,IAAI,WAAW,MAC1B,MAAM,KAAK,CAAC,OAAO,KAAK,GACxB,MAAM,MAAM,OAAO,CAAC,OAAO,KAAK;AACtC,QAAO,IAAI,SAAS,GAAG,MAAM;;AAG/B,MAAa,YAAY,SACvB,MACA,QACA,MACA;AACA,KAAI,QAAQ,OAAO,CAAE,QAAO;AAC5B,KAAI,WAAW,IAAK,QAAO,CAAC;AAC5B,QAAO,MAAM,KAAK,CAAC,OAAO,KAAK,CAAC,OAAO,OAAO;;AAGhD,MAAa,YAAY,OAAe,WAA4B;CAClE,MAAM,MAAiB,EAAE;CACzB,MAAM,cAAc,UAAU;AAC9B,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,IACzB,KAAI,KAAK,aAAa,SAAS,EAAE,IAAI,MAAM;AAE7C,QAAO;;AAGT,MAAa,mBAAmB,cAAsC;AACpE,QAAO,QAAQ,UAAU,GACpB,UAAU,KAAK,MAAM,EAAE,QAAQ,CAAC,GACjC,UAAU,QAAQ"}

frontend/node_modules/element-plus/es/components/time-picker/style/css.mjs

@@ -0,0 +1,5 @@
+import "../../base/style/css.mjs";
+import "../../input/style/css.mjs";
+import "../../scrollbar/style/css.mjs";
+import "../../popper/style/css.mjs";
+import "element-plus/theme-chalk/el-time-picker.css";

frontend/node_modules/element-plus/es/components/time-picker/style/index.mjs

@@ -0,0 +1,5 @@
+import "../../base/style/index.mjs";
+import "../../input/style/index.mjs";
+import "../../scrollbar/style/index.mjs";
+import "../../popper/style/index.mjs";
+import "element-plus/theme-chalk/src/time-picker.scss";