前端初始化

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/basic-time-spinner.js

@@ -0,0 +1,10 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region ../../packages/components/time-picker/src/time-picker-com/basic-time-spinner.vue
+var basic_time_spinner_default = require("./basic-time-spinner.vue_vue_type_script_setup_true_lang.js").default;
+//#endregion
+exports.default = basic_time_spinner_default;
+
+//# sourceMappingURL=basic-time-spinner.js.map

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/basic-time-spinner.vue.d.ts

@@ -0,0 +1,90 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.js";
+import { GetDisabledHours, GetDisabledMinutes, GetDisabledSeconds } from "../common/props.js";
+import * as _$vue from "vue";
+import * as _$dayjs from "dayjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/basic-time-spinner.vue.d.ts
+declare const __VLS_export: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  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 role: {
+    readonly type: _$vue.PropType<string>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly spinnerDate: {
+    readonly type: _$vue.PropType<_$dayjs.Dayjs>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly showSeconds: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly arrowControl: BooleanConstructor;
+  readonly amPmMode: EpPropFinalized<(new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A") | (((new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A")) | null)[], unknown, unknown, "", boolean>;
+}>, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {
+  change: (...args: any[]) => void;
+  "select-range": (...args: any[]) => void;
+  "set-option": (...args: any[]) => void;
+}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  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 role: {
+    readonly type: _$vue.PropType<string>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly spinnerDate: {
+    readonly type: _$vue.PropType<_$dayjs.Dayjs>;
+    readonly required: true;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+  };
+  readonly showSeconds: EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+  readonly arrowControl: BooleanConstructor;
+  readonly amPmMode: EpPropFinalized<(new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A") | (((new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A")) | null)[], unknown, unknown, "", boolean>;
+}>> & Readonly<{
+  onChange?: ((...args: any[]) => any) | undefined;
+  "onSelect-range"?: ((...args: any[]) => any) | undefined;
+  "onSet-option"?: ((...args: any[]) => any) | undefined;
+}>, {
+  readonly arrowControl: boolean;
+  readonly showSeconds: EpPropMergeType<BooleanConstructor, unknown, unknown>;
+  readonly amPmMode: EpPropMergeType<(new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A") | (((new (...args: any[]) => "" | "a" | "A") | (() => "" | "a" | "A")) | null)[], unknown, unknown>;
+}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { _default as default };

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/basic-time-spinner.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,284 @@
+require("../../../../_virtual/_rolldown/runtime.js");
+const require_event = require("../../../../constants/event.js");
+const require_types = require("../../../../utils/types.js");
+const require_raf = require("../../../../utils/raf.js");
+const require_style = require("../../../../utils/dom/style.js");
+const require_index = require("../../../../hooks/use-namespace/index.js");
+const require_index$1 = require("../../../icon/index.js");
+const require_index$2 = require("../../../scrollbar/index.js");
+const require_constants = require("../constants.js");
+const require_utils = require("../utils.js");
+const require_use_time_picker = require("../composables/use-time-picker.js");
+const require_index$3 = require("../../../../directives/repeat-click/index.js");
+const require_basic_time_spinner = require("../props/basic-time-spinner.js");
+let lodash_unified = require("lodash-unified");
+let _element_plus_icons_vue = require("@element-plus/icons-vue");
+let vue = require("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__ */ (0, vue.defineComponent)({
+	__name: "basic-time-spinner",
+	props: require_basic_time_spinner.basicTimeSpinnerProps,
+	emits: [
+		require_event.CHANGE_EVENT,
+		"select-range",
+		"set-option"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const { isRange, format, saveOnBlur } = (0, vue.inject)(require_constants.PICKER_BASE_INJECTION_KEY).props;
+		const emit = __emit;
+		const ns = require_index.useNamespace("time");
+		const { getHoursList, getMinutesList, getSecondsList } = require_use_time_picker.getTimeLists(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
+		let isScrolling = false;
+		const ignoreScroll = {
+			hours: false,
+			minutes: false,
+			seconds: false
+		};
+		const currentScrollbar = (0, vue.ref)();
+		const listRefsMap = {
+			hours: (0, vue.ref)(),
+			minutes: (0, vue.ref)(),
+			seconds: (0, vue.ref)()
+		};
+		const spinnerItems = (0, vue.computed)(() => {
+			return props.showSeconds ? require_constants.timeUnits : require_constants.timeUnits.slice(0, 2);
+		});
+		const timePartials = (0, vue.computed)(() => {
+			const { spinnerDate } = props;
+			return {
+				hours: spinnerDate.hour(),
+				minutes: spinnerDate.minute(),
+				seconds: spinnerDate.second()
+			};
+		});
+		const timeList = (0, vue.computed)(() => {
+			const { hours, minutes } = (0, vue.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 = (0, vue.computed)(() => {
+			const { hours, minutes, seconds } = (0, vue.unref)(timePartials);
+			return {
+				hours: require_utils.buildTimeList(hours, 23),
+				minutes: require_utils.buildTimeList(minutes, 59),
+				seconds: require_utils.buildTimeList(seconds, 59)
+			};
+		});
+		const debouncedResetScroll = (0, lodash_unified.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 || "HH:mm:ss";
+			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, (0, vue.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 = (0, vue.unref)(listRefsMap[type]);
+			if (scrollbar && scrollbar.$el) {
+				if (!saveOnBlur) {
+					ignoreScroll[type] = true;
+					require_raf.rAF(() => {
+						ignoreScroll[type] = false;
+					});
+				}
+				getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type));
+			}
+		};
+		const typeItemHeight = (type) => {
+			const listItem = (0, vue.unref)(listRefsMap[type])?.$el.querySelector("li");
+			if (listItem) return Number.parseFloat(require_style.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 = (0, vue.unref)(timePartials)[label];
+			const next = findNextUnDisabled(label, now, step, currentScrollbar.value === "hours" ? 24 : 60);
+			modifyDateField(label, next);
+			adjustSpinner(label, next);
+			(0, vue.nextTick)(() => emitSelectRange(label));
+		};
+		const findNextUnDisabled = (type, now, step, total) => {
+			let next = (now + step + total) % total;
+			const list = (0, vue.unref)(timeList)[type];
+			while (list[next] && next !== now) next = (next + step + total) % total;
+			return next;
+		};
+		const modifyDateField = (type, value) => {
+			if ((0, vue.unref)(timeList)[type][value]) return;
+			const { hours, minutes, seconds } = (0, vue.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(require_event.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 = (0, vue.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 (0, vue.unref)(listRefsMap[type]).$el.offsetHeight;
+		};
+		const bindScrollEvent = () => {
+			const bindFunction = (type) => {
+				const scrollbar = (0, vue.unref)(listRefsMap[type]);
+				if (scrollbar && scrollbar.$el) getScrollbarElement(scrollbar.$el).onscroll = () => {
+					handleScroll(type);
+				};
+			};
+			bindFunction("hours");
+			bindFunction("minutes");
+			bindFunction("seconds");
+		};
+		(0, vue.onMounted)(() => {
+			(0, vue.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]);
+		(0, vue.watch)(() => props.spinnerDate, () => {
+			if (isScrolling) return;
+			adjustSpinners();
+		});
+		return (_ctx, _cache) => {
+			return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", { class: (0, vue.normalizeClass)([(0, vue.unref)(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }]) }, [!_ctx.arrowControl ? ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, (0, vue.renderList)(spinnerItems.value, (item) => {
+				return (0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_index$2.ElScrollbar), {
+					key: item,
+					ref_for: true,
+					ref: (scrollbar) => setRef(scrollbar, item),
+					class: (0, vue.normalizeClass)((0, vue.unref)(ns).be("spinner", "wrapper")),
+					"wrap-style": "max-height: inherit;",
+					"view-class": (0, vue.unref)(ns).be("spinner", "list"),
+					noresize: "",
+					tag: "ul",
+					onMouseenter: ($event) => emitSelectRange(item),
+					onMousemove: ($event) => adjustCurrentSpinner(item)
+				}, {
+					default: (0, vue.withCtx)(() => [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(timeList.value[item], (disabled, key) => {
+						return (0, vue.openBlock)(), (0, vue.createElementBlock)("li", {
+							key,
+							class: (0, vue.normalizeClass)([
+								(0, vue.unref)(ns).be("spinner", "item"),
+								(0, vue.unref)(ns).is("active", key === timePartials.value[item]),
+								(0, vue.unref)(ns).is("disabled", disabled)
+							]),
+							onClick: ($event) => handleClick(item, {
+								value: key,
+								disabled
+							})
+						}, [item === "hours" ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [(0, vue.createTextVNode)((0, vue.toDisplayString)(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + (0, vue.toDisplayString)(getAmPmFlag(key)), 1)], 64)) : ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, [(0, vue.createTextVNode)((0, vue.toDisplayString)(("0" + key).slice(-2)), 1)], 64))], 10, _hoisted_1);
+					}), 128))]),
+					_: 2
+				}, 1032, [
+					"class",
+					"view-class",
+					"onMouseenter",
+					"onMousemove"
+				]);
+			}), 128)) : (0, vue.createCommentVNode)("v-if", true), _ctx.arrowControl ? ((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, (0, vue.renderList)(spinnerItems.value, (item) => {
+				return (0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+					key: item,
+					class: (0, vue.normalizeClass)([(0, vue.unref)(ns).be("spinner", "wrapper"), (0, vue.unref)(ns).is("arrow")]),
+					onMouseenter: ($event) => emitSelectRange(item)
+				}, [
+					(0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_index$1.ElIcon), { class: (0, vue.normalizeClass)(["arrow-up", (0, vue.unref)(ns).be("spinner", "arrow")]) }, {
+						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_element_plus_icons_vue.ArrowUp))]),
+						_: 1
+					}, 8, ["class"])), [[(0, vue.unref)(require_index$3.vRepeatClick), onDecrement]]),
+					(0, vue.withDirectives)(((0, vue.openBlock)(), (0, vue.createBlock)((0, vue.unref)(require_index$1.ElIcon), { class: (0, vue.normalizeClass)(["arrow-down", (0, vue.unref)(ns).be("spinner", "arrow")]) }, {
+						default: (0, vue.withCtx)(() => [(0, vue.createVNode)((0, vue.unref)(_element_plus_icons_vue.ArrowDown))]),
+						_: 1
+					}, 8, ["class"])), [[(0, vue.unref)(require_index$3.vRepeatClick), onIncrement]]),
+					(0, vue.createElementVNode)("ul", { class: (0, vue.normalizeClass)((0, vue.unref)(ns).be("spinner", "list")) }, [((0, vue.openBlock)(true), (0, vue.createElementBlock)(vue.Fragment, null, (0, vue.renderList)(arrowControlTimeList.value[item], (time, key) => {
+						return (0, vue.openBlock)(), (0, vue.createElementBlock)("li", {
+							key,
+							class: (0, vue.normalizeClass)([
+								(0, vue.unref)(ns).be("spinner", "item"),
+								(0, vue.unref)(ns).is("active", time === timePartials.value[item]),
+								(0, vue.unref)(ns).is("disabled", timeList.value[item][time])
+							])
+						}, [(0, vue.unref)(require_types.isNumber)(time) ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [item === "hours" ? ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 0 }, [(0, vue.createTextVNode)((0, vue.toDisplayString)(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + (0, vue.toDisplayString)(getAmPmFlag(time)), 1)], 64)) : ((0, vue.openBlock)(), (0, vue.createElementBlock)(vue.Fragment, { key: 1 }, [(0, vue.createTextVNode)((0, vue.toDisplayString)(("0" + time).slice(-2)), 1)], 64))], 64)) : (0, vue.createCommentVNode)("v-if", true)], 2);
+					}), 128))], 2)
+				], 42, _hoisted_2);
+			}), 128)) : (0, vue.createCommentVNode)("v-if", true)], 2);
+		};
+	}
+});
+//#endregion
+exports.default = basic_time_spinner_vue_vue_type_script_setup_true_lang_default;
+
+//# sourceMappingURL=basic-time-spinner.vue_vue_type_script_setup_true_lang.js.map

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-pick.js

@@ -0,0 +1,10 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-pick.vue
+var panel_time_pick_default = require("./panel-time-pick.vue_vue_type_script_setup_true_lang.js").default;
+//#endregion
+exports.default = panel_time_pick_default;
+
+//# sourceMappingURL=panel-time-pick.js.map

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

@@ -0,0 +1,43 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.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;
+  "set-picker-option": (...args: any[]) => void;
+  "select-range": (...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;
+  "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+  "onSelect-range"?: ((...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 as default };

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-pick.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,175 @@
+const require_runtime = require("../../../../_virtual/_rolldown/runtime.js");
+const require_aria = require("../../../../constants/aria.js");
+const require_event = require("../../../../utils/dom/event.js");
+const require_types = require("../../../../utils/types.js");
+const require_index = require("../../../../hooks/use-locale/index.js");
+const require_index$1 = require("../../../../hooks/use-namespace/index.js");
+const require_constants = require("../constants.js");
+const require_panel_time_picker = require("../props/panel-time-picker.js");
+const require_use_time_panel = require("../composables/use-time-panel.js");
+const require_use_time_picker = require("../composables/use-time-picker.js");
+const require_basic_time_spinner = require("./basic-time-spinner.js");
+let vue = require("vue");
+let dayjs = require("dayjs");
+dayjs = require_runtime.__toESM(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__ */ (0, vue.defineComponent)({
+	__name: "panel-time-pick",
+	props: require_panel_time_picker.panelTimePickerProps,
+	emits: [
+		"pick",
+		"select-range",
+		"set-picker-option"
+	],
+	setup(__props, { emit: __emit }) {
+		const props = __props;
+		const emit = __emit;
+		const pickerBase = (0, vue.inject)(require_constants.PICKER_BASE_INJECTION_KEY);
+		const { arrowControl, disabledHours, disabledMinutes, disabledSeconds, defaultValue } = pickerBase.props;
+		const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = require_use_time_picker.buildAvailableTimeSlotGetter(disabledHours, disabledMinutes, disabledSeconds);
+		const ns = require_index$1.useNamespace("time");
+		const { t, lang } = require_index.useLocale();
+		const selectionRange = (0, vue.ref)([0, 2]);
+		const oldValue = require_use_time_picker.useOldValue(props, {
+			modelValue: (0, vue.computed)(() => pickerBase.props.modelValue),
+			valueOnClear: (0, vue.computed)(() => pickerBase?.emptyValues ? pickerBase.emptyValues.valueOnClear.value : null)
+		});
+		const transitionName = (0, vue.computed)(() => {
+			return require_types.isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
+		});
+		const showSeconds = (0, vue.computed)(() => {
+			return props.format.includes("ss");
+		});
+		const amPmMode = (0, vue.computed)(() => {
+			if (props.format.includes("A")) return "A";
+			if (props.format.includes("a")) return "a";
+			return "";
+		});
+		const isValidValue = (_date) => {
+			const parsedDate = (0, dayjs.default)(_date).locale(lang.value);
+			const result = getRangeAvailableTime(parsedDate);
+			return parsedDate.isSame(result);
+		};
+		const handleCancel = () => {
+			const old = oldValue.value;
+			emit("pick", old, false);
+			(0, vue.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 = require_event.getEventCode(event);
+			const { left, right, up, down } = require_aria.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 } = require_use_time_panel.useTimePanel({
+			getAvailableHours,
+			getAvailableMinutes,
+			getAvailableSeconds
+		});
+		const getRangeAvailableTime = (date) => {
+			return getAvailableTime(date, props.datetimeRole || "", true);
+		};
+		const parseUserInput = (value) => {
+			if (!value) return null;
+			return (0, dayjs.default)(value, props.format).locale(lang.value);
+		};
+		const getDefaultValue = () => {
+			return (0, dayjs.default)(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 (0, vue.openBlock)(), (0, vue.createBlock)(vue.Transition, { name: transitionName.value }, {
+				default: (0, vue.withCtx)(() => [_ctx.actualVisible || _ctx.visible ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+					key: 0,
+					class: (0, vue.normalizeClass)((0, vue.unref)(ns).b("panel"))
+				}, [(0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)([(0, vue.unref)(ns).be("panel", "content"), { "has-seconds": showSeconds.value }]) }, [(0, vue.createVNode)(require_basic_time_spinner.default, {
+					ref: "spinner",
+					role: _ctx.datetimeRole || "start",
+					"arrow-control": (0, vue.unref)(arrowControl),
+					"show-seconds": showSeconds.value,
+					"am-pm-mode": amPmMode.value,
+					"spinner-date": _ctx.parsedValue,
+					"disabled-hours": (0, vue.unref)(disabledHours),
+					"disabled-minutes": (0, vue.unref)(disabledMinutes),
+					"disabled-seconds": (0, vue.unref)(disabledSeconds),
+					onChange: handleChange,
+					onSetOption: (0, vue.unref)(onSetOption),
+					onSelectRange: setSelectionRange
+				}, null, 8, [
+					"role",
+					"arrow-control",
+					"show-seconds",
+					"am-pm-mode",
+					"spinner-date",
+					"disabled-hours",
+					"disabled-minutes",
+					"disabled-seconds",
+					"onSetOption"
+				])], 2), (0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)((0, vue.unref)(ns).be("panel", "footer")) }, [(0, vue.createElementVNode)("button", {
+					type: "button",
+					class: (0, vue.normalizeClass)([(0, vue.unref)(ns).be("panel", "btn"), "cancel"]),
+					onClick: handleCancel
+				}, (0, vue.toDisplayString)((0, vue.unref)(t)("el.datepicker.cancel")), 3), (0, vue.createElementVNode)("button", {
+					type: "button",
+					class: (0, vue.normalizeClass)([(0, vue.unref)(ns).be("panel", "btn"), "confirm"]),
+					onClick: _cache[0] || (_cache[0] = ($event) => handleConfirm())
+				}, (0, vue.toDisplayString)((0, vue.unref)(t)("el.datepicker.confirm")), 3)], 2)], 2)) : (0, vue.createCommentVNode)("v-if", true)]),
+				_: 1
+			}, 8, ["name"]);
+		};
+	}
+});
+//#endregion
+exports.default = panel_time_pick_vue_vue_type_script_setup_true_lang_default;
+
+//# sourceMappingURL=panel-time-pick.vue_vue_type_script_setup_true_lang.js.map

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-range.js

@@ -0,0 +1,10 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-range.vue
+var panel_time_range_default = require("./panel-time-range.vue_vue_type_script_setup_true_lang.js").default;
+//#endregion
+exports.default = panel_time_range_default;
+
+//# sourceMappingURL=panel-time-range.js.map

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-range.vue.d.ts

@@ -0,0 +1,41 @@
+import { EpPropFinalized, EpPropMergeType } from "../../../../utils/vue/props/types.js";
+import * as _$vue from "vue";
+import dayjs from "dayjs";
+
+//#region ../../packages/components/time-picker/src/time-picker-com/panel-time-range.vue.d.ts
+declare const __VLS_export: _$vue.DefineComponent<_$vue.ExtractPropTypes<{
+  readonly parsedValue: {
+    readonly type: _$vue.PropType<[dayjs.Dayjs, 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;
+  "set-picker-option": (...args: any[]) => void;
+  "select-range": (...args: any[]) => void;
+}, string, _$vue.PublicProps, Readonly<_$vue.ExtractPropTypes<{
+  readonly parsedValue: {
+    readonly type: _$vue.PropType<[dayjs.Dayjs, 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;
+  "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+  "onSelect-range"?: ((...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 as default };

node_modules/element-plus/lib/components/time-picker/src/time-picker-com/panel-time-range.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1,246 @@
+const require_runtime = require("../../../../_virtual/_rolldown/runtime.js");
+const require_aria = require("../../../../constants/aria.js");
+const require_event = require("../../../../utils/dom/event.js");
+const require_index = require("../../../../hooks/use-locale/index.js");
+const require_index$1 = require("../../../../hooks/use-namespace/index.js");
+const require_constants = require("../constants.js");
+const require_use_time_panel = require("../composables/use-time-panel.js");
+const require_use_time_picker = require("../composables/use-time-picker.js");
+const require_basic_time_spinner = require("./basic-time-spinner.js");
+const require_panel_time_range = require("../props/panel-time-range.js");
+let lodash_unified = require("lodash-unified");
+let vue = require("vue");
+let dayjs = require("dayjs");
+dayjs = require_runtime.__toESM(dayjs);
+let _vue_shared = require("@vue/shared");
+//#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__ */ (0, vue.defineComponent)({
+	__name: "panel-time-range",
+	props: require_panel_time_range.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 } = require_index.useLocale();
+		const nsTime = require_index$1.useNamespace("time");
+		const nsPicker = require_index$1.useNamespace("picker");
+		const pickerBase = (0, vue.inject)(require_constants.PICKER_BASE_INJECTION_KEY);
+		const { arrowControl, disabledHours, disabledMinutes, disabledSeconds, defaultValue } = pickerBase.props;
+		const startContainerKls = (0, vue.computed)(() => [
+			nsTime.be("range-picker", "body"),
+			nsTime.be("panel", "content"),
+			nsTime.is("arrow", arrowControl),
+			showSeconds.value ? "has-seconds" : ""
+		]);
+		const endContainerKls = (0, vue.computed)(() => [
+			nsTime.be("range-picker", "body"),
+			nsTime.be("panel", "content"),
+			nsTime.is("arrow", arrowControl),
+			showSeconds.value ? "has-seconds" : ""
+		]);
+		const startTime = (0, vue.computed)(() => props.parsedValue[0]);
+		const endTime = (0, vue.computed)(() => props.parsedValue[1]);
+		const oldValue = require_use_time_picker.useOldValue(props, {
+			modelValue: (0, vue.computed)(() => pickerBase.props.modelValue),
+			valueOnClear: (0, vue.computed)(() => pickerBase?.emptyValues ? pickerBase.emptyValues.valueOnClear.value : null)
+		});
+		const handleCancel = () => {
+			const old = oldValue.value;
+			emit("pick", old, false);
+			(0, vue.nextTick)(() => {
+				oldValue.value = old;
+			});
+		};
+		const showSeconds = (0, vue.computed)(() => {
+			return props.format.includes("ss");
+		});
+		const amPmMode = (0, vue.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((_) => (0, dayjs.default)(_).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 = (0, vue.computed)(() => {
+			return startTime.value > endTime.value;
+		});
+		const selectionRange = (0, vue.ref)([0, 2]);
+		const setMinSelectionRange = (start, end) => {
+			emit("select-range", start, end, "min");
+			selectionRange.value = [start, end];
+		};
+		const offset = (0, vue.computed)(() => showSeconds.value ? 11 : 8);
+		const setMaxSelectionRange = (start, end) => {
+			emit("select-range", start, end, "max");
+			const _offset = (0, vue.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 = require_event.getEventCode(event);
+			const { left, right, up, down } = require_aria.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 (0, lodash_unified.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 (0, lodash_unified.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 (0, lodash_unified.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 } = require_use_time_picker.buildAvailableTimeSlotGetter(disabledHours_, disabledMinutes_, disabledSeconds_);
+		const { timePickerOptions, getAvailableTime, onSetOption } = require_use_time_panel.useTimePanel({
+			getAvailableHours,
+			getAvailableMinutes,
+			getAvailableSeconds
+		});
+		const parseUserInput = (days) => {
+			if (!days) return null;
+			if ((0, _vue_shared.isArray)(days)) return days.map((d) => (0, dayjs.default)(d, props.format).locale(lang.value));
+			return (0, dayjs.default)(days, props.format).locale(lang.value);
+		};
+		const getDefaultValue = () => {
+			if ((0, _vue_shared.isArray)(defaultValue)) return defaultValue.map((d) => (0, dayjs.default)(d).locale(lang.value));
+			const defaultDay = (0, dayjs.default)(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 ? ((0, vue.openBlock)(), (0, vue.createElementBlock)("div", {
+				key: 0,
+				class: (0, vue.normalizeClass)([(0, vue.unref)(nsTime).b("range-picker"), (0, vue.unref)(nsPicker).b("panel")])
+			}, [(0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)((0, vue.unref)(nsTime).be("range-picker", "content")) }, [(0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)((0, vue.unref)(nsTime).be("range-picker", "cell")) }, [(0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)((0, vue.unref)(nsTime).be("range-picker", "header")) }, (0, vue.toDisplayString)((0, vue.unref)(t)("el.datepicker.startTime")), 3), (0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)(startContainerKls.value) }, [(0, vue.createVNode)(require_basic_time_spinner.default, {
+				ref: "minSpinner",
+				role: "start",
+				"show-seconds": showSeconds.value,
+				"am-pm-mode": amPmMode.value,
+				"arrow-control": (0, vue.unref)(arrowControl),
+				"spinner-date": startTime.value,
+				"disabled-hours": disabledHours_,
+				"disabled-minutes": disabledMinutes_,
+				"disabled-seconds": disabledSeconds_,
+				onChange: handleMinChange,
+				onSetOption: (0, vue.unref)(onSetOption),
+				onSelectRange: setMinSelectionRange
+			}, null, 8, [
+				"show-seconds",
+				"am-pm-mode",
+				"arrow-control",
+				"spinner-date",
+				"onSetOption"
+			])], 2)], 2), (0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)((0, vue.unref)(nsTime).be("range-picker", "cell")) }, [(0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)((0, vue.unref)(nsTime).be("range-picker", "header")) }, (0, vue.toDisplayString)((0, vue.unref)(t)("el.datepicker.endTime")), 3), (0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)(endContainerKls.value) }, [(0, vue.createVNode)(require_basic_time_spinner.default, {
+				ref: "maxSpinner",
+				role: "end",
+				"show-seconds": showSeconds.value,
+				"am-pm-mode": amPmMode.value,
+				"arrow-control": (0, vue.unref)(arrowControl),
+				"spinner-date": endTime.value,
+				"disabled-hours": disabledHours_,
+				"disabled-minutes": disabledMinutes_,
+				"disabled-seconds": disabledSeconds_,
+				onChange: handleMaxChange,
+				onSetOption: (0, vue.unref)(onSetOption),
+				onSelectRange: setMaxSelectionRange
+			}, null, 8, [
+				"show-seconds",
+				"am-pm-mode",
+				"arrow-control",
+				"spinner-date",
+				"onSetOption"
+			])], 2)], 2)], 2), (0, vue.createElementVNode)("div", { class: (0, vue.normalizeClass)((0, vue.unref)(nsTime).be("panel", "footer")) }, [(0, vue.createElementVNode)("button", {
+				type: "button",
+				class: (0, vue.normalizeClass)([(0, vue.unref)(nsTime).be("panel", "btn"), "cancel"]),
+				onClick: _cache[0] || (_cache[0] = ($event) => handleCancel())
+			}, (0, vue.toDisplayString)((0, vue.unref)(t)("el.datepicker.cancel")), 3), (0, vue.createElementVNode)("button", {
+				type: "button",
+				class: (0, vue.normalizeClass)([(0, vue.unref)(nsTime).be("panel", "btn"), "confirm"]),
+				disabled: btnConfirmDisabled.value,
+				onClick: _cache[1] || (_cache[1] = ($event) => handleConfirm())
+			}, (0, vue.toDisplayString)((0, vue.unref)(t)("el.datepicker.confirm")), 11, _hoisted_1)], 2)], 2)) : (0, vue.createCommentVNode)("v-if", true);
+		};
+	}
+});
+//#endregion
+exports.default = panel_time_range_vue_vue_type_script_setup_true_lang_default;
+
+//# sourceMappingURL=panel-time-range.vue_vue_type_script_setup_true_lang.js.map