init

node_modules/element-plus/lib/components/date-picker-panel/index.d.ts

@@ -0,0 +1,8 @@
+import DatePickerPanel from './src/date-picker-panel';
+import type { SFCWithInstall } from 'element-plus/es/utils';
+export declare const ElDatePickerPanel: SFCWithInstall<typeof DatePickerPanel>;
+export default ElDatePickerPanel;
+export * from './src/constants';
+export * from './src/props/date-picker-panel';
+export * from './src/types';
+export type { DatePickerPanelInstance } from './src/instance';

node_modules/element-plus/lib/components/date-picker-panel/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var datePickerPanel$1 = require('./src/date-picker-panel.js');
+var constants = require('./src/constants.js');
+var datePickerPanel = require('./src/props/date-picker-panel.js');
+var install = require('../../utils/vue/install.js');
+
+const ElDatePickerPanel = install.withInstall(datePickerPanel$1["default"]);
+
+exports.ROOT_PICKER_INJECTION_KEY = constants.ROOT_PICKER_INJECTION_KEY;
+exports.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = constants.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY;
+exports.datePickerPanelProps = datePickerPanel.datePickerPanelProps;
+exports.ElDatePickerPanel = ElDatePickerPanel;
+exports["default"] = ElDatePickerPanel;
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/date-picker-panel/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../packages/components/date-picker-panel/index.ts"],"sourcesContent":["import { withInstall } from '@element-plus/utils'\nimport DatePickerPanel from './src/date-picker-panel'\n\nimport type { SFCWithInstall } from '@element-plus/utils'\n\nexport const ElDatePickerPanel: SFCWithInstall<typeof DatePickerPanel> =\n  withInstall(DatePickerPanel)\n\nexport default ElDatePickerPanel\nexport * from './src/constants'\nexport * from './src/props/date-picker-panel'\nexport * from './src/types'\nexport type { DatePickerPanelInstance } from './src/instance'\n"],"names":["withInstall","DatePickerPanel"],"mappings":";;;;;;;;;AAEY,MAAC,iBAAiB,GAAGA,mBAAW,CAACC,4BAAe;;;;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-basic-date-table.d.ts

@@ -0,0 +1,247 @@
+import dayjs from 'dayjs';
+import type { SetupContext } from 'vue';
+import type { DateCell } from '../types';
+import type { BasicDateTableEmits, BasicDateTableProps } from '../props/basic-date-table';
+export declare const useBasicDateTable: (props: BasicDateTableProps, emit: SetupContext<BasicDateTableEmits>["emit"]) => {
+    WEEKS: import("vue").ComputedRef<string[]>;
+    rows: import("vue").ComputedRef<{
+        column?: number | undefined;
+        customClass?: string | undefined;
+        disabled?: boolean | undefined;
+        end?: boolean | undefined;
+        inRange?: boolean | undefined;
+        row?: number | undefined;
+        selected?: {
+            clone: () => Dayjs;
+            isValid: () => boolean;
+            year: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            month: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            date: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            day: {
+                (): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+                (value: number): Dayjs;
+            };
+            hour: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            minute: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            second: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            millisecond: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            set: (unit: dayjs.UnitType, value: number) => Dayjs;
+            get: (unit: dayjs.UnitType) => number;
+            add: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            subtract: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            startOf: (unit: dayjs.OpUnitType) => Dayjs;
+            endOf: (unit: dayjs.OpUnitType) => Dayjs;
+            format: (template?: string) => string;
+            diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+            valueOf: () => number;
+            unix: () => number;
+            daysInMonth: () => number;
+            toDate: () => Date;
+            toJSON: () => string;
+            toISOString: () => string;
+            toString: () => string;
+            utcOffset: () => number;
+            isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            locale: {
+                (): string;
+                (preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
+            };
+            localeData: () => dayjs.InstanceLocaleDataReturn;
+            week: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            weekYear: () => number;
+            dayOfYear: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            isSameOrAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSameOrBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        } | undefined;
+        isCurrent?: boolean | undefined;
+        isSelected?: boolean | undefined;
+        start?: boolean | undefined;
+        text?: number | undefined;
+        renderText?: string | undefined;
+        timestamp?: number | undefined;
+        date?: {
+            toString: () => string;
+            toDateString: () => string;
+            toTimeString: () => string;
+            toLocaleString: {
+                (): string;
+                (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+            };
+            toLocaleDateString: {
+                (): string;
+                (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+            };
+            toLocaleTimeString: {
+                (): string;
+                (locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
+            };
+            valueOf: () => number;
+            getTime: () => number;
+            getFullYear: () => number;
+            getUTCFullYear: () => number;
+            getMonth: () => number;
+            getUTCMonth: () => number;
+            getDate: () => number;
+            getUTCDate: () => number;
+            getDay: () => number;
+            getUTCDay: () => number;
+            getHours: () => number;
+            getUTCHours: () => number;
+            getMinutes: () => number;
+            getUTCMinutes: () => number;
+            getSeconds: () => number;
+            getUTCSeconds: () => number;
+            getMilliseconds: () => number;
+            getUTCMilliseconds: () => number;
+            getTimezoneOffset: () => number;
+            setTime: (time: number) => number;
+            setMilliseconds: (ms: number) => number;
+            setUTCMilliseconds: (ms: number) => number;
+            setSeconds: (sec: number, ms?: number) => number;
+            setUTCSeconds: (sec: number, ms?: number) => number;
+            setMinutes: (min: number, sec?: number, ms?: number) => number;
+            setUTCMinutes: (min: number, sec?: number, ms?: number) => number;
+            setHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
+            setUTCHours: (hours: number, min?: number, sec?: number, ms?: number) => number;
+            setDate: (date: number) => number;
+            setUTCDate: (date: number) => number;
+            setMonth: (month: number, date?: number) => number;
+            setUTCMonth: (month: number, date?: number) => number;
+            setFullYear: (year: number, month?: number, date?: number) => number;
+            setUTCFullYear: (year: number, month?: number, date?: number) => number;
+            toUTCString: () => string;
+            toISOString: () => string;
+            toJSON: (key?: any) => string;
+            [Symbol.toPrimitive]: {
+                (hint: "default"): string;
+                (hint: "string"): string;
+                (hint: "number"): number;
+                (hint: string): string | number;
+            };
+        } | undefined;
+        dayjs?: {
+            clone: () => Dayjs;
+            isValid: () => boolean;
+            year: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            month: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            date: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            day: {
+                (): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+                (value: number): Dayjs;
+            };
+            hour: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            minute: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            second: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            millisecond: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            set: (unit: dayjs.UnitType, value: number) => Dayjs;
+            get: (unit: dayjs.UnitType) => number;
+            add: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            subtract: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            startOf: (unit: dayjs.OpUnitType) => Dayjs;
+            endOf: (unit: dayjs.OpUnitType) => Dayjs;
+            format: (template?: string) => string;
+            diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+            valueOf: () => number;
+            unix: () => number;
+            daysInMonth: () => number;
+            toDate: () => Date;
+            toJSON: () => string;
+            toISOString: () => string;
+            toString: () => string;
+            utcOffset: () => number;
+            isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            locale: {
+                (): string;
+                (preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
+            };
+            localeData: () => dayjs.InstanceLocaleDataReturn;
+            week: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            weekYear: () => number;
+            dayOfYear: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            isSameOrAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSameOrBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        } | undefined;
+        type?: ("normal" | "week" | "today" | "prev-month" | "next-month") | undefined;
+    }[][]>;
+    tbodyRef: import("vue").Ref<HTMLElement | undefined>;
+    currentCellRef: import("vue").Ref<HTMLElement | undefined>;
+    focus: () => Promise<void | undefined>;
+    isCurrent: (cell: DateCell) => boolean;
+    isWeekActive: (cell: DateCell) => boolean;
+    isSelectedCell: (cell: DateCell) => boolean | undefined;
+    handlePickDate: (event: FocusEvent | MouseEvent, isKeyboardMovement?: boolean) => void;
+    handleMouseUp: (event: MouseEvent) => void;
+    handleMouseDown: (event: MouseEvent) => void;
+    handleMouseMove: (event: MouseEvent) => void;
+    handleFocus: (event: FocusEvent) => void;
+};
+export declare const useBasicDateTableDOM: (props: BasicDateTableProps, { isCurrent, isWeekActive, }: Pick<ReturnType<typeof useBasicDateTable>, "isCurrent" | "isWeekActive">) => {
+    tableKls: import("vue").ComputedRef<(string | {
+        'is-week-mode': boolean;
+    })[]>;
+    tableLabel: import("vue").ComputedRef<string>;
+    weekHeaderClass: string;
+    getCellClasses: (cell: DateCell) => string;
+    getRowKls: (cell: DateCell) => (string | {
+        current: boolean;
+    })[];
+    t: import("element-plus/es/hooks").Translator;
+};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-basic-date-table.js

@@ -0,0 +1,358 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var lodashUnified = require('lodash-unified');
+var utils = require('../utils.js');
+var index = require('../../../../hooks/use-locale/index.js');
+var arrays = require('../../../../utils/arrays.js');
+var index$1 = require('../../../../hooks/use-namespace/index.js');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const isNormalDay = (type = "") => {
+  return ["normal", "today"].includes(type);
+};
+const useBasicDateTable = (props, emit) => {
+  const { lang } = index.useLocale();
+  const tbodyRef = vue.ref();
+  const currentCellRef = vue.ref();
+  const lastRow = vue.ref();
+  const lastColumn = vue.ref();
+  const tableRows = vue.ref([[], [], [], [], [], []]);
+  let focusWithClick = false;
+  const firstDayOfWeek = props.date.$locale().weekStart || 7;
+  const WEEKS_CONSTANT = props.date.locale("en").localeData().weekdaysShort().map((_) => _.toLowerCase());
+  const offsetDay = vue.computed(() => {
+    return firstDayOfWeek > 3 ? 7 - firstDayOfWeek : -firstDayOfWeek;
+  });
+  const startDate = vue.computed(() => {
+    const startDayOfMonth = props.date.startOf("month");
+    return startDayOfMonth.subtract(startDayOfMonth.day() || 7, "day");
+  });
+  const WEEKS = vue.computed(() => {
+    return WEEKS_CONSTANT.concat(WEEKS_CONSTANT).slice(firstDayOfWeek, firstDayOfWeek + 7);
+  });
+  const hasCurrent = vue.computed(() => {
+    return lodashUnified.flatten(vue.unref(rows)).some((row) => {
+      return row.isCurrent;
+    });
+  });
+  const days = vue.computed(() => {
+    const startOfMonth = props.date.startOf("month");
+    const startOfMonthDay = startOfMonth.day() || 7;
+    const dateCountOfMonth = startOfMonth.daysInMonth();
+    const dateCountOfLastMonth = startOfMonth.subtract(1, "month").daysInMonth();
+    return {
+      startOfMonthDay,
+      dateCountOfMonth,
+      dateCountOfLastMonth
+    };
+  });
+  const selectedDate = vue.computed(() => {
+    return props.selectionMode === "dates" ? arrays.castArray(props.parsedValue) : [];
+  });
+  const setDateText = (cell, { count, rowIndex, columnIndex }) => {
+    const { startOfMonthDay, dateCountOfMonth, dateCountOfLastMonth } = vue.unref(days);
+    const offset = vue.unref(offsetDay);
+    if (rowIndex >= 0 && rowIndex <= 1) {
+      const numberOfDaysFromPreviousMonth = startOfMonthDay + offset < 0 ? 7 + startOfMonthDay + offset : startOfMonthDay + offset;
+      if (columnIndex + rowIndex * 7 >= numberOfDaysFromPreviousMonth) {
+        cell.text = count;
+        return true;
+      } else {
+        cell.text = dateCountOfLastMonth - (numberOfDaysFromPreviousMonth - columnIndex % 7) + 1 + rowIndex * 7;
+        cell.type = "prev-month";
+      }
+    } else {
+      if (count <= dateCountOfMonth) {
+        cell.text = count;
+      } else {
+        cell.text = count - dateCountOfMonth;
+        cell.type = "next-month";
+      }
+      return true;
+    }
+    return false;
+  };
+  const setCellMetadata = (cell, { columnIndex, rowIndex }, count) => {
+    const { disabledDate, cellClassName } = props;
+    const _selectedDate = vue.unref(selectedDate);
+    const shouldIncrement = setDateText(cell, { count, rowIndex, columnIndex });
+    const cellDate = cell.dayjs.toDate();
+    cell.selected = _selectedDate.find((d) => d.isSame(cell.dayjs, "day"));
+    cell.isSelected = !!cell.selected;
+    cell.isCurrent = isCurrent(cell);
+    cell.disabled = disabledDate == null ? void 0 : disabledDate(cellDate);
+    cell.customClass = cellClassName == null ? void 0 : cellClassName(cellDate);
+    return shouldIncrement;
+  };
+  const setRowMetadata = (row) => {
+    if (props.selectionMode === "week") {
+      const [start, end] = props.showWeekNumber ? [1, 7] : [0, 6];
+      const isActive = isWeekActive(row[start + 1]);
+      row[start].inRange = isActive;
+      row[start].start = isActive;
+      row[end].inRange = isActive;
+      row[end].end = isActive;
+    }
+  };
+  const rows = vue.computed(() => {
+    const { minDate, maxDate, rangeState, showWeekNumber } = props;
+    const offset = vue.unref(offsetDay);
+    const rows_ = vue.unref(tableRows);
+    const dateUnit = "day";
+    let count = 1;
+    utils.buildPickerTable({ row: 6, column: 7 }, rows_, {
+      startDate: minDate,
+      columnIndexOffset: showWeekNumber ? 1 : 0,
+      nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
+      now: dayjs__default["default"]().locale(vue.unref(lang)).startOf(dateUnit),
+      unit: dateUnit,
+      relativeDateGetter: (idx) => vue.unref(startDate).add(idx - offset, dateUnit),
+      setCellMetadata: (...args) => {
+        if (setCellMetadata(...args, count)) {
+          count += 1;
+        }
+      },
+      setRowMetadata
+    });
+    if (showWeekNumber) {
+      for (let rowIndex = 0; rowIndex < 6; rowIndex++) {
+        if (rows_[rowIndex][1].dayjs) {
+          rows_[rowIndex][0] = {
+            type: "week",
+            text: rows_[rowIndex][1].dayjs.week()
+          };
+        }
+      }
+    }
+    return rows_;
+  });
+  vue.watch(() => props.date, async () => {
+    var _a;
+    if ((_a = vue.unref(tbodyRef)) == null ? void 0 : _a.contains(document.activeElement)) {
+      await vue.nextTick();
+      await focus();
+    }
+  });
+  const focus = async () => {
+    var _a;
+    return (_a = vue.unref(currentCellRef)) == null ? void 0 : _a.focus();
+  };
+  const isCurrent = (cell) => {
+    return props.selectionMode === "date" && isNormalDay(cell.type) && cellMatchesDate(cell, props.parsedValue);
+  };
+  const cellMatchesDate = (cell, date) => {
+    if (!date)
+      return false;
+    return dayjs__default["default"](date).locale(vue.unref(lang)).isSame(props.date.date(Number(cell.text)), "day");
+  };
+  const getDateOfCell = (row, column) => {
+    const offsetFromStart = row * 7 + (column - (props.showWeekNumber ? 1 : 0)) - vue.unref(offsetDay);
+    return vue.unref(startDate).add(offsetFromStart, "day");
+  };
+  const handleMouseMove = (event) => {
+    var _a;
+    if (!props.rangeState.selecting)
+      return;
+    let target = event.target;
+    if (target.tagName === "SPAN") {
+      target = (_a = target.parentNode) == null ? void 0 : _a.parentNode;
+    }
+    if (target.tagName === "DIV") {
+      target = target.parentNode;
+    }
+    if (target.tagName !== "TD")
+      return;
+    const row = target.parentNode.rowIndex - 1;
+    const column = target.cellIndex;
+    if (vue.unref(rows)[row][column].disabled)
+      return;
+    if (row !== vue.unref(lastRow) || column !== vue.unref(lastColumn)) {
+      lastRow.value = row;
+      lastColumn.value = column;
+      emit("changerange", {
+        selecting: true,
+        endDate: getDateOfCell(row, column)
+      });
+    }
+  };
+  const isSelectedCell = (cell) => {
+    return !vue.unref(hasCurrent) && (cell == null ? void 0 : cell.text) === 1 && cell.type === "normal" || cell.isCurrent;
+  };
+  const handleFocus = (event) => {
+    if (focusWithClick || vue.unref(hasCurrent) || props.selectionMode !== "date")
+      return;
+    handlePickDate(event, true);
+  };
+  const handleMouseDown = (event) => {
+    const target = event.target.closest("td");
+    if (!target)
+      return;
+    focusWithClick = true;
+  };
+  const handleMouseUp = (event) => {
+    const target = event.target.closest("td");
+    if (!target)
+      return;
+    focusWithClick = false;
+  };
+  const handleRangePick = (newDate) => {
+    if (!props.rangeState.selecting || !props.minDate) {
+      emit("pick", { minDate: newDate, maxDate: null });
+      emit("select", true);
+    } else {
+      if (newDate >= props.minDate) {
+        emit("pick", { minDate: props.minDate, maxDate: newDate });
+      } else {
+        emit("pick", { minDate: newDate, maxDate: props.minDate });
+      }
+      emit("select", false);
+    }
+  };
+  const handleWeekPick = (newDate) => {
+    const weekNumber = newDate.week();
+    const value = `${newDate.year()}w${weekNumber}`;
+    emit("pick", {
+      year: newDate.year(),
+      week: weekNumber,
+      value,
+      date: newDate.startOf("week")
+    });
+  };
+  const handleDatesPick = (newDate, selected) => {
+    const newValue = selected ? arrays.castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.valueOf()) !== newDate.valueOf()) : arrays.castArray(props.parsedValue).concat([newDate]);
+    emit("pick", newValue);
+  };
+  const handlePickDate = (event, isKeyboardMovement = false) => {
+    if (props.disabled)
+      return;
+    const target = event.target.closest("td");
+    if (!target)
+      return;
+    const row = target.parentNode.rowIndex - 1;
+    const column = target.cellIndex;
+    const cell = vue.unref(rows)[row][column];
+    if (cell.disabled || cell.type === "week")
+      return;
+    const newDate = getDateOfCell(row, column);
+    switch (props.selectionMode) {
+      case "range": {
+        handleRangePick(newDate);
+        break;
+      }
+      case "date": {
+        emit("pick", newDate, isKeyboardMovement);
+        break;
+      }
+      case "week": {
+        handleWeekPick(newDate);
+        break;
+      }
+      case "dates": {
+        handleDatesPick(newDate, !!cell.selected);
+        break;
+      }
+    }
+  };
+  const isWeekActive = (cell) => {
+    if (props.selectionMode !== "week")
+      return false;
+    let newDate = props.date.startOf("day");
+    if (cell.type === "prev-month") {
+      newDate = newDate.subtract(1, "month");
+    }
+    if (cell.type === "next-month") {
+      newDate = newDate.add(1, "month");
+    }
+    newDate = newDate.date(Number.parseInt(cell.text, 10));
+    if (props.parsedValue && !shared.isArray(props.parsedValue)) {
+      const dayOffset = (props.parsedValue.day() - firstDayOfWeek + 7) % 7 - 1;
+      const weekDate = props.parsedValue.subtract(dayOffset, "day");
+      return weekDate.isSame(newDate, "day");
+    }
+    return false;
+  };
+  return {
+    WEEKS,
+    rows,
+    tbodyRef,
+    currentCellRef,
+    focus,
+    isCurrent,
+    isWeekActive,
+    isSelectedCell,
+    handlePickDate,
+    handleMouseUp,
+    handleMouseDown,
+    handleMouseMove,
+    handleFocus
+  };
+};
+const useBasicDateTableDOM = (props, {
+  isCurrent,
+  isWeekActive
+}) => {
+  const ns = index$1.useNamespace("date-table");
+  const { t } = index.useLocale();
+  const tableKls = vue.computed(() => [
+    ns.b(),
+    { "is-week-mode": props.selectionMode === "week" && !props.disabled }
+  ]);
+  const tableLabel = vue.computed(() => t("el.datepicker.dateTablePrompt"));
+  const getCellClasses = (cell) => {
+    const classes = [];
+    if (isNormalDay(cell.type) && !cell.disabled) {
+      classes.push("available");
+      if (cell.type === "today") {
+        classes.push("today");
+      }
+    } else {
+      classes.push(cell.type);
+    }
+    if (isCurrent(cell)) {
+      classes.push("current");
+    }
+    if (cell.inRange && (isNormalDay(cell.type) || props.selectionMode === "week")) {
+      classes.push("in-range");
+      if (cell.start) {
+        classes.push("start-date");
+      }
+      if (cell.end) {
+        classes.push("end-date");
+      }
+    }
+    if (cell.disabled || props.disabled) {
+      classes.push("disabled");
+    }
+    if (cell.selected) {
+      classes.push("selected");
+    }
+    if (cell.customClass) {
+      classes.push(cell.customClass);
+    }
+    return classes.join(" ");
+  };
+  const getRowKls = (cell) => [
+    ns.e("row"),
+    { current: isWeekActive(cell) }
+  ];
+  return {
+    tableKls,
+    tableLabel,
+    weekHeaderClass: ns.e("week-header"),
+    getCellClasses,
+    getRowKls,
+    t
+  };
+};
+
+exports.useBasicDateTable = useBasicDateTable;
+exports.useBasicDateTableDOM = useBasicDateTableDOM;
+//# sourceMappingURL=use-basic-date-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-month-range-header.d.ts

@@ -0,0 +1,16 @@
+import type { Ref, ToRef } from 'vue';
+import type { Dayjs } from 'dayjs';
+export declare const useMonthRangeHeader: ({ unlinkPanels, leftDate, rightDate, }: {
+    unlinkPanels: ToRef<boolean>;
+    leftDate: Ref<Dayjs>;
+    rightDate: Ref<Dayjs>;
+}) => {
+    leftPrevYear: () => void;
+    rightNextYear: () => void;
+    leftNextYear: () => void;
+    rightPrevYear: () => void;
+    leftLabel: import("vue").ComputedRef<string>;
+    rightLabel: import("vue").ComputedRef<string>;
+    leftYear: import("vue").ComputedRef<number>;
+    rightYear: import("vue").ComputedRef<number>;
+};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-month-range-header.js

@@ -0,0 +1,57 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var index = require('../../../../hooks/use-locale/index.js');
+
+const useMonthRangeHeader = ({
+  unlinkPanels,
+  leftDate,
+  rightDate
+}) => {
+  const { t } = index.useLocale();
+  const leftPrevYear = () => {
+    leftDate.value = leftDate.value.subtract(1, "year");
+    if (!unlinkPanels.value) {
+      rightDate.value = rightDate.value.subtract(1, "year");
+    }
+  };
+  const rightNextYear = () => {
+    if (!unlinkPanels.value) {
+      leftDate.value = leftDate.value.add(1, "year");
+    }
+    rightDate.value = rightDate.value.add(1, "year");
+  };
+  const leftNextYear = () => {
+    leftDate.value = leftDate.value.add(1, "year");
+  };
+  const rightPrevYear = () => {
+    rightDate.value = rightDate.value.subtract(1, "year");
+  };
+  const leftLabel = vue.computed(() => {
+    return `${leftDate.value.year()} ${t("el.datepicker.year")}`;
+  });
+  const rightLabel = vue.computed(() => {
+    return `${rightDate.value.year()} ${t("el.datepicker.year")}`;
+  });
+  const leftYear = vue.computed(() => {
+    return leftDate.value.year();
+  });
+  const rightYear = vue.computed(() => {
+    return rightDate.value.year() === leftDate.value.year() ? leftDate.value.year() + 1 : rightDate.value.year();
+  });
+  return {
+    leftPrevYear,
+    rightNextYear,
+    leftNextYear,
+    rightPrevYear,
+    leftLabel,
+    rightLabel,
+    leftYear,
+    rightYear
+  };
+};
+
+exports.useMonthRangeHeader = useMonthRangeHeader;
+//# sourceMappingURL=use-month-range-header.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-month-range-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-month-range-header.js","sources":["../../../../../../../packages/components/date-picker-panel/src/composables/use-month-range-header.ts"],"sourcesContent":["import { computed } from 'vue'\nimport { useLocale } from '@element-plus/hooks'\n\nimport type { Ref, ToRef } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const useMonthRangeHeader = ({\n  unlinkPanels,\n  leftDate,\n  rightDate,\n}: {\n  unlinkPanels: ToRef<boolean>\n  leftDate: Ref<Dayjs>\n  rightDate: Ref<Dayjs>\n}) => {\n  const { t } = useLocale()\n  const leftPrevYear = () => {\n    leftDate.value = leftDate.value.subtract(1, 'year')\n    if (!unlinkPanels.value) {\n      rightDate.value = rightDate.value.subtract(1, 'year')\n    }\n  }\n\n  const rightNextYear = () => {\n    if (!unlinkPanels.value) {\n      leftDate.value = leftDate.value.add(1, 'year')\n    }\n    rightDate.value = rightDate.value.add(1, 'year')\n  }\n\n  const leftNextYear = () => {\n    leftDate.value = leftDate.value.add(1, 'year')\n  }\n\n  const rightPrevYear = () => {\n    rightDate.value = rightDate.value.subtract(1, 'year')\n  }\n  const leftLabel = computed(() => {\n    return `${leftDate.value.year()} ${t('el.datepicker.year')}`\n  })\n\n  const rightLabel = computed(() => {\n    return `${rightDate.value.year()} ${t('el.datepicker.year')}`\n  })\n\n  const leftYear = computed(() => {\n    return leftDate.value.year()\n  })\n\n  const rightYear = computed(() => {\n    return rightDate.value.year() === leftDate.value.year()\n      ? leftDate.value.year() + 1\n      : rightDate.value.year()\n  })\n\n  return {\n    leftPrevYear,\n    rightNextYear,\n    leftNextYear,\n    rightPrevYear,\n    leftLabel,\n    rightLabel,\n    leftYear,\n    rightYear,\n  }\n}\n"],"names":["useLocale","computed"],"mappings":";;;;;;;AAEY,MAAC,mBAAmB,GAAG,CAAC;AACpC,EAAE,YAAY;AACd,EAAE,QAAQ;AACV,EAAE,SAAS;AACX,CAAC,KAAK;AACN,EAAE,MAAM,EAAE,CAAC,EAAE,GAAGA,eAAS,EAAE,CAAC;AAC5B,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACxD,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAC5D,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACrD,KAAK;AACL,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACrD,GAAG,CAAC;AACJ,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AACnD,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAC1D,GAAG,CAAC;AACJ,EAAE,MAAM,SAAS,GAAGC,YAAQ,CAAC,MAAM;AACnC,IAAI,OAAO,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;AACjE,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,UAAU,GAAGA,YAAQ,CAAC,MAAM;AACpC,IAAI,OAAO,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC;AAClE,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,QAAQ,GAAGA,YAAQ,CAAC,MAAM;AAClC,IAAI,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;AACjC,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,SAAS,GAAGA,YAAQ,CAAC,MAAM;AACnC,IAAI,OAAO,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;AACjH,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,QAAQ;AACZ,IAAI,SAAS;AACb,GAAG,CAAC;AACJ;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-panel-date-range.d.ts

@@ -0,0 +1,29 @@
+import type { PanelDateRangeProps } from '../props/panel-date-range';
+import type { Dayjs } from 'dayjs';
+import type { ComputedRef, Ref } from 'vue';
+type CurrentView = 'date' | 'year' | 'month';
+type CurrentViewRef = {
+    focus: () => void;
+};
+export type Emits = (event: 'pick' | 'set-picker-option' | 'calendar-change' | 'panel-change', ...args: any[]) => void;
+export declare const usePanelDateRange: (props: PanelDateRangeProps, emit: Emits, leftDate: Ref<Dayjs>, rightDate: Ref<Dayjs>) => {
+    leftCurrentView: Ref<CurrentView>;
+    rightCurrentView: Ref<CurrentView>;
+    leftCurrentViewRef: Ref<CurrentViewRef | undefined>;
+    rightCurrentViewRef: Ref<CurrentViewRef | undefined>;
+    leftYear: ComputedRef<number>;
+    rightYear: ComputedRef<number>;
+    leftMonth: ComputedRef<number>;
+    rightMonth: ComputedRef<number>;
+    leftYearLabel: ComputedRef<string>;
+    rightYearLabel: ComputedRef<string>;
+    showLeftPicker: (view: "month" | "year") => Promise<void>;
+    showRightPicker: (view: "month" | "year") => Promise<void>;
+    handleLeftYearPick: (year: number) => Promise<void>;
+    handleRightYearPick: (year: number) => Promise<void>;
+    handleLeftMonthPick: (month: number) => Promise<void>;
+    handleRightMonthPick: (month: number) => Promise<void>;
+    handlePanelChange: (mode: "month" | "year") => void;
+    adjustDateByView: (currentView: CurrentView, date: Dayjs, forward: boolean) => Dayjs;
+};
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-panel-date-range.js

@@ -0,0 +1,103 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var utils = require('../utils.js');
+var constants = require('../../../time-picker/src/constants.js');
+var index = require('../../../../hooks/use-locale/index.js');
+
+const usePanelDateRange = (props, emit, leftDate, rightDate) => {
+  const leftCurrentView = vue.ref("date");
+  const leftCurrentViewRef = vue.ref();
+  const rightCurrentView = vue.ref("date");
+  const rightCurrentViewRef = vue.ref();
+  const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
+  const { disabledDate } = pickerBase.props;
+  const { t, lang } = index.useLocale();
+  const leftYear = vue.computed(() => {
+    return leftDate.value.year();
+  });
+  const leftMonth = vue.computed(() => {
+    return leftDate.value.month();
+  });
+  const rightYear = vue.computed(() => {
+    return rightDate.value.year();
+  });
+  const rightMonth = vue.computed(() => {
+    return rightDate.value.month();
+  });
+  function computedYearLabel(currentView, yearValue) {
+    const yearTranslation = t("el.datepicker.year");
+    if (currentView.value === "year") {
+      const startYear = Math.floor(yearValue.value / 10) * 10;
+      return yearTranslation ? `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}` : `${startYear} - ${startYear + 9}`;
+    }
+    return `${yearValue.value} ${yearTranslation}`;
+  }
+  function focusPicker(currentViewRef) {
+    currentViewRef == null ? void 0 : currentViewRef.focus();
+  }
+  async function showPicker(pickerType, view) {
+    if (props.disabled)
+      return;
+    const currentView = pickerType === "left" ? leftCurrentView : rightCurrentView;
+    const currentViewRef = pickerType === "left" ? leftCurrentViewRef : rightCurrentViewRef;
+    currentView.value = view;
+    await vue.nextTick();
+    focusPicker(currentViewRef.value);
+  }
+  async function handlePick(mode, pickerType, value) {
+    if (props.disabled)
+      return;
+    const isLeftPicker = pickerType === "left";
+    const startDate = isLeftPicker ? leftDate : rightDate;
+    const endDate = isLeftPicker ? rightDate : leftDate;
+    const currentView = isLeftPicker ? leftCurrentView : rightCurrentView;
+    const currentViewRef = isLeftPicker ? leftCurrentViewRef : rightCurrentViewRef;
+    if (mode === "year") {
+      const data = startDate.value.year(value);
+      startDate.value = utils.getValidDateOfYear(data, lang.value, disabledDate);
+    }
+    if (mode === "month") {
+      startDate.value = utils.getValidDateOfMonth(startDate.value, startDate.value.year(), value, lang.value, disabledDate);
+    }
+    if (!props.unlinkPanels) {
+      endDate.value = pickerType === "left" ? startDate.value.add(1, "month") : startDate.value.subtract(1, "month");
+    }
+    currentView.value = mode === "year" ? "month" : "date";
+    await vue.nextTick();
+    focusPicker(currentViewRef.value);
+    handlePanelChange(mode);
+  }
+  function handlePanelChange(mode) {
+    emit("panel-change", [leftDate.value.toDate(), rightDate.value.toDate()], mode);
+  }
+  function adjustDateByView(currentView, date, forward) {
+    const action = forward ? "add" : "subtract";
+    return currentView === "year" ? date[action](10, "year") : date[action](1, "year");
+  }
+  return {
+    leftCurrentView,
+    rightCurrentView,
+    leftCurrentViewRef,
+    rightCurrentViewRef,
+    leftYear,
+    rightYear,
+    leftMonth,
+    rightMonth,
+    leftYearLabel: vue.computed(() => computedYearLabel(leftCurrentView, leftYear)),
+    rightYearLabel: vue.computed(() => computedYearLabel(rightCurrentView, rightYear)),
+    showLeftPicker: (view) => showPicker("left", view),
+    showRightPicker: (view) => showPicker("right", view),
+    handleLeftYearPick: (year) => handlePick("year", "left", year),
+    handleRightYearPick: (year) => handlePick("year", "right", year),
+    handleLeftMonthPick: (month) => handlePick("month", "left", month),
+    handleRightMonthPick: (month) => handlePick("month", "right", month),
+    handlePanelChange,
+    adjustDateByView
+  };
+};
+
+exports.usePanelDateRange = usePanelDateRange;
+//# sourceMappingURL=use-panel-date-range.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-range-picker.d.ts

@@ -0,0 +1,136 @@
+import dayjs from 'dayjs';
+import type { Ref } from 'vue';
+import type { Dayjs } from 'dayjs';
+import type { PanelRangeSharedProps, RangeState } from '../props/shared';
+import type { DefaultValue } from '../utils';
+type UseRangePickerProps = {
+    sortDates: (minDate: Dayjs | undefined, maxDate: Dayjs | undefined) => void;
+    defaultValue: Ref<DefaultValue>;
+    defaultTime?: Ref<DefaultValue>;
+    leftDate: Ref<Dayjs>;
+    rightDate: Ref<Dayjs>;
+    step?: number;
+    unit: 'month' | 'year';
+};
+export declare const useRangePicker: (props: PanelRangeSharedProps, { defaultValue, defaultTime, leftDate, rightDate, step, unit, sortDates, }: UseRangePickerProps) => {
+    minDate: Ref<dayjs.Dayjs | undefined>;
+    maxDate: Ref<dayjs.Dayjs | undefined>;
+    rangeState: Ref<{
+        endDate: {
+            clone: () => Dayjs;
+            isValid: () => boolean;
+            year: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            month: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            date: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            day: {
+                (): 0 | 1 | 2 | 3 | 4 | 5 | 6;
+                (value: number): Dayjs;
+            };
+            hour: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            minute: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            second: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            millisecond: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            set: (unit: dayjs.UnitType, value: number) => Dayjs;
+            get: (unit: dayjs.UnitType) => number;
+            add: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            subtract: (value: number, unit?: dayjs.ManipulateType) => Dayjs;
+            startOf: (unit: dayjs.OpUnitType) => Dayjs;
+            endOf: (unit: dayjs.OpUnitType) => Dayjs;
+            format: (template?: string) => string;
+            diff: (date?: dayjs.ConfigType, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) => number;
+            valueOf: () => number;
+            unix: () => number;
+            daysInMonth: () => number;
+            toDate: () => Date;
+            toJSON: () => string;
+            toISOString: () => string;
+            toString: () => string;
+            utcOffset: () => number;
+            isBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSame: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            locale: {
+                (): string;
+                (preset: string | ILocale, object?: Partial<ILocale>): Dayjs;
+            };
+            localeData: () => dayjs.InstanceLocaleDataReturn;
+            week: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            weekYear: () => number;
+            dayOfYear: {
+                (): number;
+                (value: number): Dayjs;
+            };
+            isSameOrAfter: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+            isSameOrBefore: (date?: dayjs.ConfigType, unit?: dayjs.OpUnitType) => boolean;
+        } | null;
+        selecting: boolean;
+    }>;
+    lang: Ref<string>;
+    ppNs: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    drpNs: {
+        namespace: import("vue").ComputedRef<string>;
+        b: (blockSuffix?: string) => string;
+        e: (element?: string) => string;
+        m: (modifier?: string) => string;
+        be: (blockSuffix?: string, element?: string) => string;
+        em: (element?: string, modifier?: string) => string;
+        bm: (blockSuffix?: string, modifier?: string) => string;
+        bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
+        is: {
+            (name: string, state: boolean | undefined): string;
+            (name: string): string;
+        };
+        cssVar: (object: Record<string, string>) => Record<string, string>;
+        cssVarName: (name: string) => string;
+        cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+        cssVarBlockName: (name: string) => string;
+    };
+    handleChangeRange: (val: RangeState) => void;
+    handleRangeConfirm: (visible?: boolean) => void;
+    handleShortcutClick: (shortcut: import("./use-shortcut").Shortcut) => void;
+    onSelect: (selecting: boolean) => void;
+    parseValue: (parsedValue: PanelRangeSharedProps["parsedValue"]) => void;
+    t: import("element-plus/es/hooks").Translator;
+};
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-range-picker.js

@@ -0,0 +1,131 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var lodashUnified = require('lodash-unified');
+var utils = require('../utils.js');
+var constants = require('../constants.js');
+var useShortcut = require('./use-shortcut.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+var index$1 = require('../../../../hooks/use-locale/index.js');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const useRangePicker = (props, {
+  defaultValue,
+  defaultTime,
+  leftDate,
+  rightDate,
+  step,
+  unit,
+  sortDates
+}) => {
+  const { emit } = vue.getCurrentInstance();
+  const { pickerNs } = vue.inject(constants.ROOT_PICKER_INJECTION_KEY);
+  const drpNs = index.useNamespace("date-range-picker");
+  const { t, lang } = index$1.useLocale();
+  const handleShortcutClick = useShortcut.useShortcut(lang);
+  const minDate = vue.ref();
+  const maxDate = vue.ref();
+  const rangeState = vue.ref({
+    endDate: null,
+    selecting: false
+  });
+  const handleChangeRange = (val) => {
+    rangeState.value = val;
+  };
+  const handleRangeConfirm = (visible = false) => {
+    const _minDate = vue.unref(minDate);
+    const _maxDate = vue.unref(maxDate);
+    if (utils.isValidRange([_minDate, _maxDate])) {
+      emit("pick", [_minDate, _maxDate], visible);
+    }
+  };
+  const onSelect = (selecting) => {
+    rangeState.value.selecting = selecting;
+    if (!selecting) {
+      rangeState.value.endDate = null;
+    }
+  };
+  const parseValue = (parsedValue) => {
+    if (shared.isArray(parsedValue) && parsedValue.length === 2) {
+      const [start, end] = parsedValue;
+      minDate.value = start;
+      leftDate.value = start;
+      maxDate.value = end;
+      sortDates(vue.unref(minDate), vue.unref(maxDate));
+    } else {
+      restoreDefault();
+    }
+  };
+  const restoreDefault = () => {
+    let [start, end] = utils.getDefaultValue(vue.unref(defaultValue), {
+      lang: vue.unref(lang),
+      step,
+      unit,
+      unlinkPanels: props.unlinkPanels
+    });
+    const getShift = (day) => {
+      return day.diff(day.startOf("d"), "ms");
+    };
+    const maybeTimes = vue.unref(defaultTime);
+    if (maybeTimes) {
+      let leftShift = 0;
+      let rightShift = 0;
+      if (shared.isArray(maybeTimes)) {
+        const [timeStart, timeEnd] = maybeTimes.map(dayjs__default["default"]);
+        leftShift = getShift(timeStart);
+        rightShift = getShift(timeEnd);
+      } else {
+        const shift = getShift(dayjs__default["default"](maybeTimes));
+        leftShift = shift;
+        rightShift = shift;
+      }
+      start = start.startOf("d").add(leftShift, "ms");
+      end = end.startOf("d").add(rightShift, "ms");
+    }
+    minDate.value = void 0;
+    maxDate.value = void 0;
+    leftDate.value = start;
+    rightDate.value = end;
+  };
+  vue.watch(defaultValue, (val) => {
+    if (val) {
+      restoreDefault();
+    }
+  }, { immediate: true });
+  vue.watch(() => props.parsedValue, (parsedValue) => {
+    if (!(parsedValue == null ? void 0 : parsedValue.length) || !lodashUnified.isEqual(parsedValue, [minDate.value, maxDate.value])) {
+      parseValue(parsedValue);
+    }
+  }, {
+    immediate: true
+  });
+  vue.watch(() => props.visible, () => {
+    if (props.visible) {
+      parseValue(props.parsedValue);
+    }
+  }, { immediate: true });
+  return {
+    minDate,
+    maxDate,
+    rangeState,
+    lang,
+    ppNs: pickerNs,
+    drpNs,
+    handleChangeRange,
+    handleRangeConfirm,
+    handleShortcutClick,
+    onSelect,
+    parseValue,
+    t
+  };
+};
+
+exports.useRangePicker = useRangePicker;
+//# sourceMappingURL=use-range-picker.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-shortcut.d.ts

@@ -0,0 +1,9 @@
+import type { SetupContext } from 'vue';
+import type { useLocale } from 'element-plus/es/hooks';
+import type { RangePickerSharedEmits } from '../props/shared';
+export type Shortcut = {
+    text: string;
+    value: [Date, Date] | (() => [Date, Date]);
+    onClick?: (ctx: Omit<SetupContext<RangePickerSharedEmits>, 'expose'>) => void;
+};
+export declare const useShortcut: (lang: ReturnType<typeof useLocale>["lang"]) => (shortcut: Shortcut) => void;

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-shortcut.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const useShortcut = (lang) => {
+  const { emit } = vue.getCurrentInstance();
+  const attrs = vue.useAttrs();
+  const slots = vue.useSlots();
+  const handleShortcutClick = (shortcut) => {
+    const shortcutValues = shared.isFunction(shortcut.value) ? shortcut.value() : shortcut.value;
+    if (shortcutValues) {
+      emit("pick", [
+        dayjs__default["default"](shortcutValues[0]).locale(lang.value),
+        dayjs__default["default"](shortcutValues[1]).locale(lang.value)
+      ]);
+      return;
+    }
+    if (shortcut.onClick) {
+      shortcut.onClick({
+        attrs,
+        slots,
+        emit
+      });
+    }
+  };
+  return handleShortcutClick;
+};
+
+exports.useShortcut = useShortcut;
+//# sourceMappingURL=use-shortcut.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-shortcut.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-shortcut.js","sources":["../../../../../../../packages/components/date-picker-panel/src/composables/use-shortcut.ts"],"sourcesContent":["import { getCurrentInstance, useAttrs, useSlots } from 'vue'\nimport dayjs from 'dayjs'\nimport { isFunction } from '@element-plus/utils'\n\nimport type { SetupContext } from 'vue'\nimport type { useLocale } from '@element-plus/hooks'\nimport type { RangePickerSharedEmits } from '../props/shared'\n\n// FIXME: extract this to `date-picker.ts`\nexport type Shortcut = {\n  text: string\n  value: [Date, Date] | (() => [Date, Date])\n  onClick?: (ctx: Omit<SetupContext<RangePickerSharedEmits>, 'expose'>) => void\n}\n\nexport const useShortcut = (lang: ReturnType<typeof useLocale>['lang']) => {\n  const { emit } = getCurrentInstance()!\n  const attrs = useAttrs()\n  const slots = useSlots()\n\n  const handleShortcutClick = (shortcut: Shortcut) => {\n    const shortcutValues = isFunction(shortcut.value)\n      ? shortcut.value()\n      : shortcut.value\n\n    if (shortcutValues) {\n      emit('pick', [\n        dayjs(shortcutValues[0]).locale(lang.value),\n        dayjs(shortcutValues[1]).locale(lang.value),\n      ])\n      return\n    }\n    if (shortcut.onClick) {\n      shortcut.onClick({\n        attrs,\n        slots,\n        emit,\n      })\n    }\n  }\n\n  return handleShortcutClick\n}\n"],"names":["getCurrentInstance","useAttrs","useSlots","isFunction","dayjs"],"mappings":";;;;;;;;;;;;AAGY,MAAC,WAAW,GAAG,CAAC,IAAI,KAAK;AACrC,EAAE,MAAM,EAAE,IAAI,EAAE,GAAGA,sBAAkB,EAAE,CAAC;AACxC,EAAE,MAAM,KAAK,GAAGC,YAAQ,EAAE,CAAC;AAC3B,EAAE,MAAM,KAAK,GAAGC,YAAQ,EAAE,CAAC;AAC3B,EAAE,MAAM,mBAAmB,GAAG,CAAC,QAAQ,KAAK;AAC5C,IAAI,MAAM,cAAc,GAAGC,iBAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,KAAK,EAAE,GAAG,QAAQ,CAAC,KAAK,CAAC;AAC1F,IAAI,IAAI,cAAc,EAAE;AACxB,MAAM,IAAI,CAAC,MAAM,EAAE;AACnB,QAAQC,yBAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;AACnD,QAAQA,yBAAK,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;AACnD,OAAO,CAAC,CAAC;AACT,MAAM,OAAO;AACb,KAAK;AACL,IAAI,IAAI,QAAQ,CAAC,OAAO,EAAE;AAC1B,MAAM,QAAQ,CAAC,OAAO,CAAC;AACvB,QAAQ,KAAK;AACb,QAAQ,KAAK;AACb,QAAQ,IAAI;AACZ,OAAO,CAAC,CAAC;AACT,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,OAAO,mBAAmB,CAAC;AAC7B;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-year-range-header.d.ts

@@ -0,0 +1,16 @@
+import type { Ref, ToRef } from 'vue';
+import type { Dayjs } from 'dayjs';
+export declare const useYearRangeHeader: ({ unlinkPanels, leftDate, rightDate, }: {
+    unlinkPanels: ToRef<boolean>;
+    leftDate: Ref<Dayjs>;
+    rightDate: Ref<Dayjs>;
+}) => {
+    leftPrevYear: () => void;
+    rightNextYear: () => void;
+    leftNextYear: () => void;
+    rightPrevYear: () => void;
+    leftLabel: import("vue").ComputedRef<string>;
+    rightLabel: import("vue").ComputedRef<string>;
+    leftYear: import("vue").ComputedRef<number>;
+    rightYear: import("vue").ComputedRef<number>;
+};

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-year-range-header.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const useYearRangeHeader = ({
+  unlinkPanels,
+  leftDate,
+  rightDate
+}) => {
+  const leftPrevYear = () => {
+    leftDate.value = leftDate.value.subtract(10, "year");
+    if (!unlinkPanels.value) {
+      rightDate.value = rightDate.value.subtract(10, "year");
+    }
+  };
+  const rightNextYear = () => {
+    if (!unlinkPanels.value) {
+      leftDate.value = leftDate.value.add(10, "year");
+    }
+    rightDate.value = rightDate.value.add(10, "year");
+  };
+  const leftNextYear = () => {
+    leftDate.value = leftDate.value.add(10, "year");
+  };
+  const rightPrevYear = () => {
+    rightDate.value = rightDate.value.subtract(10, "year");
+  };
+  const leftLabel = vue.computed(() => {
+    const leftStartDate = Math.floor(leftDate.value.year() / 10) * 10;
+    return `${leftStartDate}-${leftStartDate + 9}`;
+  });
+  const rightLabel = vue.computed(() => {
+    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
+    return `${rightStartDate}-${rightStartDate + 9}`;
+  });
+  const leftYear = vue.computed(() => {
+    const leftEndDate = Math.floor(leftDate.value.year() / 10) * 10 + 9;
+    return leftEndDate;
+  });
+  const rightYear = vue.computed(() => {
+    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10;
+    return rightStartDate;
+  });
+  return {
+    leftPrevYear,
+    rightNextYear,
+    leftNextYear,
+    rightPrevYear,
+    leftLabel,
+    rightLabel,
+    leftYear,
+    rightYear
+  };
+};
+
+exports.useYearRangeHeader = useYearRangeHeader;
+//# sourceMappingURL=use-year-range-header.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/composables/use-year-range-header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-year-range-header.js","sources":["../../../../../../../packages/components/date-picker-panel/src/composables/use-year-range-header.ts"],"sourcesContent":["import { computed } from 'vue'\n\nimport type { Ref, ToRef } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const useYearRangeHeader = ({\n  unlinkPanels,\n  leftDate,\n  rightDate,\n}: {\n  unlinkPanels: ToRef<boolean>\n  leftDate: Ref<Dayjs>\n  rightDate: Ref<Dayjs>\n}) => {\n  const leftPrevYear = () => {\n    leftDate.value = leftDate.value.subtract(10, 'year')\n    if (!unlinkPanels.value) {\n      rightDate.value = rightDate.value.subtract(10, 'year')\n    }\n  }\n\n  const rightNextYear = () => {\n    if (!unlinkPanels.value) {\n      leftDate.value = leftDate.value.add(10, 'year')\n    }\n    rightDate.value = rightDate.value.add(10, 'year')\n  }\n\n  const leftNextYear = () => {\n    leftDate.value = leftDate.value.add(10, 'year')\n  }\n\n  const rightPrevYear = () => {\n    rightDate.value = rightDate.value.subtract(10, 'year')\n  }\n\n  const leftLabel = computed(() => {\n    const leftStartDate = Math.floor(leftDate.value.year() / 10) * 10\n    return `${leftStartDate}-${leftStartDate + 9}`\n  })\n\n  const rightLabel = computed(() => {\n    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10\n    return `${rightStartDate}-${rightStartDate + 9}`\n  })\n\n  const leftYear = computed(() => {\n    const leftEndDate = Math.floor(leftDate.value.year() / 10) * 10 + 9\n    return leftEndDate\n  })\n\n  const rightYear = computed(() => {\n    const rightStartDate = Math.floor(rightDate.value.year() / 10) * 10\n    return rightStartDate\n  })\n\n  return {\n    leftPrevYear,\n    rightNextYear,\n    leftNextYear,\n    rightPrevYear,\n    leftLabel,\n    rightLabel,\n    leftYear,\n    rightYear,\n  }\n}\n"],"names":["computed"],"mappings":";;;;;;AACY,MAAC,kBAAkB,GAAG,CAAC;AACnC,EAAE,YAAY;AACd,EAAE,QAAQ;AACV,EAAE,SAAS;AACX,CAAC,KAAK;AACN,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACzD,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AAC7D,KAAK;AACL,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE;AAC7B,MAAM,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACtD,KAAK;AACL,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACtD,GAAG,CAAC;AACJ,EAAE,MAAM,YAAY,GAAG,MAAM;AAC7B,IAAI,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AACpD,GAAG,CAAC;AACJ,EAAE,MAAM,aAAa,GAAG,MAAM;AAC9B,IAAI,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;AAC3D,GAAG,CAAC;AACJ,EAAE,MAAM,SAAS,GAAGA,YAAQ,CAAC,MAAM;AACnC,IAAI,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACtE,IAAI,OAAO,CAAC,EAAE,aAAa,CAAC,CAAC,EAAE,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC;AACnD,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,UAAU,GAAGA,YAAQ,CAAC,MAAM;AACpC,IAAI,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACxE,IAAI,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,EAAE,cAAc,GAAG,CAAC,CAAC,CAAC,CAAC;AACrD,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,QAAQ,GAAGA,YAAQ,CAAC,MAAM;AAClC,IAAI,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AACxE,IAAI,OAAO,WAAW,CAAC;AACvB,GAAG,CAAC,CAAC;AACL,EAAE,MAAM,SAAS,GAAGA,YAAQ,CAAC,MAAM;AACnC,IAAI,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACxE,IAAI,OAAO,cAAc,CAAC;AAC1B,GAAG,CAAC,CAAC;AACL,EAAE,OAAO;AACT,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,YAAY;AAChB,IAAI,aAAa;AACjB,IAAI,SAAS;AACb,IAAI,UAAU;AACd,IAAI,QAAQ;AACZ,IAAI,SAAS;AACb,GAAG,CAAC;AACJ;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/constants.d.ts

@@ -0,0 +1,9 @@
+import type { InjectionKey, SetupContext } from 'vue';
+import type { UseNamespaceReturn } from 'element-plus/es/hooks';
+interface DatePickerContext {
+    slots: SetupContext['slots'];
+    pickerNs: UseNamespaceReturn;
+}
+export declare const ROOT_PICKER_INJECTION_KEY: InjectionKey<DatePickerContext>;
+export declare const ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = "ElIsDefaultFormat";
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/constants.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ROOT_PICKER_INJECTION_KEY = Symbol("rootPickerContextKey");
+const ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = "ElIsDefaultFormat";
+
+exports.ROOT_PICKER_INJECTION_KEY = ROOT_PICKER_INJECTION_KEY;
+exports.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY;
+//# sourceMappingURL=constants.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sources":["../../../../../../packages/components/date-picker-panel/src/constants.ts"],"sourcesContent":["import type { InjectionKey, SetupContext } from 'vue'\nimport type { UseNamespaceReturn } from '@element-plus/hooks'\n\ninterface DatePickerContext {\n  slots: SetupContext['slots']\n  pickerNs: UseNamespaceReturn\n}\n\nexport const ROOT_PICKER_INJECTION_KEY: InjectionKey<DatePickerContext> =\n  Symbol('rootPickerContextKey')\n\nexport const ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY = 'ElIsDefaultFormat'\n"],"names":[],"mappings":";;;;AAAY,MAAC,yBAAyB,GAAG,MAAM,CAAC,sBAAsB,EAAE;AAC5D,MAAC,2CAA2C,GAAG;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-cell-render.d.ts

@@ -0,0 +1,18 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly cell: {
+        readonly type: import("vue").PropType<import("element-plus").DateCell>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly cell: {
+        readonly type: import("vue").PropType<import("element-plus").DateCell>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {}>;
+export default _default;

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-cell-render.js

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var constants = require('../constants.js');
+var basicCell = require('../props/basic-cell.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+
+var ElDatePickerCell = vue.defineComponent({
+  name: "ElDatePickerCell",
+  props: basicCell.basicCellProps,
+  setup(props) {
+    const ns = index.useNamespace("date-table-cell");
+    const {
+      slots
+    } = vue.inject(constants.ROOT_PICKER_INJECTION_KEY);
+    return () => {
+      const {
+        cell
+      } = props;
+      return vue.renderSlot(slots, "default", {
+        ...cell
+      }, () => {
+        var _a;
+        return [vue.createVNode("div", {
+          "class": ns.b()
+        }, [vue.createVNode("span", {
+          "class": ns.e("text")
+        }, [(_a = cell == null ? void 0 : cell.renderText) != null ? _a : cell == null ? void 0 : cell.text])])];
+      });
+    };
+  }
+});
+
+exports["default"] = ElDatePickerCell;
+//# sourceMappingURL=basic-cell-render.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-cell-render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-cell-render.js","sources":["../../../../../../../packages/components/date-picker-panel/src/date-picker-com/basic-cell-render.tsx"],"sourcesContent":["import { defineComponent, inject, renderSlot } from 'vue'\nimport { useNamespace } from '@element-plus/hooks'\nimport { ROOT_PICKER_INJECTION_KEY } from '../constants'\nimport { basicCellProps } from '../props/basic-cell'\n\nexport default defineComponent({\n  name: 'ElDatePickerCell',\n  props: basicCellProps,\n  setup(props) {\n    const ns = useNamespace('date-table-cell')\n    const { slots } = inject(ROOT_PICKER_INJECTION_KEY)!\n    return () => {\n      const { cell } = props\n\n      return renderSlot(slots, 'default', { ...cell }, () => [\n        <div class={ns.b()}>\n          <span class={ns.e('text')}>{cell?.renderText ?? cell?.text}</span>\n        </div>,\n      ])\n    }\n  },\n})\n"],"names":["defineComponent","name","props","basicCellProps","useNamespace","ns","slots","inject","ROOT_PICKER_INJECTION_KEY","cell","renderSlot","_createVNode"],"mappings":";;;;;;;;;AAKA,uBAAeA,mBAAe,CAAC;AAC7BC,EAAAA,IAAI,EAAE,kBADuB;AAE7BC,EAAAA,KAAK,EAAEC,wBAFsB;;IAGxB,WAAQC,kBAAA,CAAA,iBAAA,CAAA,CAAA;AACX,IAAA,MAAMC;MACA,KAAA;AAAEC,KAAAA,GAAAA,UAAAA,CAAAA,mCAAAA,CAAAA,CAAAA;IAAF,OAAYC,MAAOC;AACzB,MAAA,MAAa;QACL,IAAA;AAAEC,OAAAA,GAAAA,KAAAA,CAAAA;AAAF,MAAA,OAANC,cAAA,CAAA,KAAA,EAAA,SAAA,EAAA;AAEA,QAAA,GAAA;AAAoC,OAAnB,EAAgC,MAAM;QAAA,IACzCL,EAAAA,CAAAA;AADyC,QAAA,OAAA,CAAAM,eAAA,CAAA,KAAA,EAAA;AAAA,UAAA,OAEtCN,EAAE,EAAF,CAAK,CAAL,EAAA;SAAeI,EAAAA,CAAAA,eAAA,CAAA;UALlC,OAAA,EAAA,EAAA,CAAA,CAAA,CAAA,MAAA,CAAA;AASD,SAAA,EAAA,CAAA,CAAA,EAAA,GAAA,IAAA,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,IAAA,CAAA,UAAA,KAAA,IAAA,GAAA,EAAA,GAAA,IAAA,IAAA,IAAA,GAAA,KAAA,CAAA,GAAA,IAAA,CAAA,IAAA,CAAA,CAAA,CAAA,CAAA,CAAA,CAAA;;AAf4B,KAA/B,CAAA;;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-date-table.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var basicDateTable = require('../props/basic-date-table.js');
+var useBasicDateTable = require('../composables/use-basic-date-table.js');
+var basicCellRender = require('./basic-cell-render.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "basic-date-table",
+  props: basicDateTable.basicDateTableProps,
+  emits: basicDateTable.basicDateTableEmits,
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const {
+      WEEKS,
+      rows,
+      tbodyRef,
+      currentCellRef,
+      focus,
+      isCurrent,
+      isWeekActive,
+      isSelectedCell,
+      handlePickDate,
+      handleMouseUp,
+      handleMouseDown,
+      handleMouseMove,
+      handleFocus
+    } = useBasicDateTable.useBasicDateTable(props, emit);
+    const { tableLabel, tableKls, getCellClasses, getRowKls, weekHeaderClass, t } = useBasicDateTable.useBasicDateTableDOM(props, {
+      isCurrent,
+      isWeekActive
+    });
+    let isUnmounting = false;
+    vue.onBeforeUnmount(() => {
+      isUnmounting = true;
+    });
+    expose({
+      focus
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("table", {
+        "aria-label": vue.unref(tableLabel),
+        class: vue.normalizeClass(vue.unref(tableKls)),
+        cellspacing: "0",
+        cellpadding: "0",
+        role: "grid",
+        onClick: vue.unref(handlePickDate),
+        onMousemove: vue.unref(handleMouseMove),
+        onMousedown: vue.unref(handleMouseDown),
+        onMouseup: vue.unref(handleMouseUp)
+      }, [
+        vue.createElementVNode("tbody", {
+          ref_key: "tbodyRef",
+          ref: tbodyRef
+        }, [
+          vue.createElementVNode("tr", null, [
+            _ctx.showWeekNumber ? (vue.openBlock(), vue.createElementBlock("th", {
+              key: 0,
+              scope: "col",
+              class: vue.normalizeClass(vue.unref(weekHeaderClass))
+            }, null, 2)) : vue.createCommentVNode("v-if", true),
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(WEEKS), (week, key) => {
+              return vue.openBlock(), vue.createElementBlock("th", {
+                key,
+                "aria-label": vue.unref(t)("el.datepicker.weeksFull." + week),
+                scope: "col"
+              }, vue.toDisplayString(vue.unref(t)("el.datepicker.weeks." + week)), 9, ["aria-label"]);
+            }), 128))
+          ]),
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, rowKey) => {
+            return vue.openBlock(), vue.createElementBlock("tr", {
+              key: rowKey,
+              class: vue.normalizeClass(vue.unref(getRowKls)(row[1]))
+            }, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, columnKey) => {
+                return vue.openBlock(), vue.createElementBlock("td", {
+                  key: `${rowKey}.${columnKey}`,
+                  ref_for: true,
+                  ref: (el) => !vue.unref(isUnmounting) && vue.unref(isSelectedCell)(cell) && (currentCellRef.value = el),
+                  class: vue.normalizeClass(vue.unref(getCellClasses)(cell)),
+                  "aria-current": cell.isCurrent ? "date" : void 0,
+                  "aria-selected": cell.isCurrent,
+                  tabindex: vue.unref(isSelectedCell)(cell) ? 0 : -1,
+                  onFocus: vue.unref(handleFocus)
+                }, [
+                  vue.createVNode(vue.unref(basicCellRender["default"]), { cell }, null, 8, ["cell"])
+                ], 42, ["aria-current", "aria-selected", "tabindex", "onFocus"]);
+              }), 128))
+            ], 2);
+          }), 128))
+        ], 512)
+      ], 42, ["aria-label", "onClick", "onMousemove", "onMousedown", "onMouseup"]);
+    };
+  }
+});
+var DateTable = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "basic-date-table.vue"]]);
+
+exports["default"] = DateTable;
+//# sourceMappingURL=basic-date-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-date-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-date-table.js","sources":["../../../../../../../packages/components/date-picker-panel/src/date-picker-com/basic-date-table.vue"],"sourcesContent":["<template>\n  <table\n    :aria-label=\"tableLabel\"\n    :class=\"tableKls\"\n    cellspacing=\"0\"\n    cellpadding=\"0\"\n    role=\"grid\"\n    @click=\"handlePickDate\"\n    @mousemove=\"handleMouseMove\"\n    @mousedown=\"handleMouseDown\"\n    @mouseup=\"handleMouseUp\"\n  >\n    <tbody ref=\"tbodyRef\">\n      <tr>\n        <th v-if=\"showWeekNumber\" scope=\"col\" :class=\"weekHeaderClass\" />\n        <th\n          v-for=\"(week, key) in WEEKS\"\n          :key=\"key\"\n          :aria-label=\"t('el.datepicker.weeksFull.' + week)\"\n          scope=\"col\"\n        >\n          {{ t('el.datepicker.weeks.' + week) }}\n        </th>\n      </tr>\n      <tr\n        v-for=\"(row, rowKey) in rows\"\n        :key=\"rowKey\"\n        :class=\"getRowKls(row[1])\"\n      >\n        <td\n          v-for=\"(cell, columnKey) in row\"\n          :key=\"`${rowKey}.${columnKey}`\"\n          :ref=\"(el) => !isUnmounting && isSelectedCell(cell) && (currentCellRef = el as HTMLElement)\"\n          :class=\"getCellClasses(cell)\"\n          :aria-current=\"cell.isCurrent ? 'date' : undefined\"\n          :aria-selected=\"cell.isCurrent\"\n          :tabindex=\"isSelectedCell(cell) ? 0 : -1\"\n          @focus=\"handleFocus\"\n        >\n          <el-date-picker-cell :cell=\"cell\" />\n        </td>\n      </tr>\n    </tbody>\n  </table>\n</template>\n\n<script lang=\"ts\" setup>\nimport { onBeforeUnmount } from 'vue'\nimport {\n  basicDateTableEmits,\n  basicDateTableProps,\n} from '../props/basic-date-table'\nimport {\n  useBasicDateTable,\n  useBasicDateTableDOM,\n} from '../composables/use-basic-date-table'\nimport ElDatePickerCell from './basic-cell-render'\n\nconst props = defineProps(basicDateTableProps)\nconst emit = defineEmits(basicDateTableEmits)\n\nconst {\n  WEEKS,\n  rows,\n  tbodyRef,\n  currentCellRef,\n\n  focus,\n  isCurrent,\n  isWeekActive,\n  isSelectedCell,\n\n  handlePickDate,\n  handleMouseUp,\n  handleMouseDown,\n  handleMouseMove,\n  handleFocus,\n} = useBasicDateTable(props, emit)\nconst { tableLabel, tableKls, getCellClasses, getRowKls, weekHeaderClass, t } =\n  useBasicDateTableDOM(props, {\n    isCurrent,\n    isWeekActive,\n  })\nlet isUnmounting = false\n\nonBeforeUnmount(() => {\n  isUnmounting = true\n})\n\ndefineExpose({\n  /**\n   * @description focus on current cell\n   */\n  focus,\n})\n</script>\n"],"names":["useBasicDateTable","useBasicDateTableDOM","onBeforeUnmount","_openBlock","_createElementBlock","_unref"],"mappings":";;;;;;;;;;;;;;;;AA6DA,IAAM,MAAA;AAAA,MACJ,KAAA;AAAA,MACA,IAAA;AAAA,MACA,QAAA;AAAA,MACA,cAAA;AAAA,MAEA,KAAA;AAAA,MACA,SAAA;AAAA,MACA,YAAA;AAAA,MACA,cAAA;AAAA,MAEA,cAAA;AAAA,MACA,aAAA;AAAA,MACA,eAAA;AAAA,MACA,eAAA;AAAA,MACA,WAAA;AAAA,KACF,GAAIA,mCAAkB,CAAA,KAAA,EAAO,IAAI,CAAA,CAAA;AACjC,IAAM,MAAA,EAAE,YAAY,QAAU,EAAA,cAAA,EAAgB,WAAW,eAAiB,EAAA,CAAA,EACxE,GAAAC,sCAAA,CAAqB,KAAO,EAAA;AAAA,MAC1B,SAAA;AAAA,MACA,YAAA;AAAA,KACD,CAAA,CAAA;AACH,IAAA,IAAI,YAAe,GAAA,KAAA,CAAA;AAEnB,IAAAC,mBAAA,CAAgB,MAAM;AACpB,MAAe,YAAA,GAAA,IAAA,CAAA;AAAA,KAChB,CAAA,CAAA;AAED,IAAa,MAAA,CAAA;AAAA,MAAA,KAAA;AAAA,KAAA,CAAA,CAAA;AAAA,IAAA,OAAA,CAAA,IAAA,EAAA,MAAA,KAAA;AAAA,MAIX,OAAAC,aAAA,EAAA,EAAAC,sBAAA,CAAA,OAAA,EAAA;AAAA,QACD,YAAA,EAAAC,SAAA,CAAA,UAAA,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-date-table.vue.d.ts

@@ -0,0 +1,102 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly showWeekNumber: BooleanConstructor;
+    readonly selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<import("../props/shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<import("../props/shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly date: {
+        readonly type: import("vue").PropType<import("dayjs").Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | ((new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState) | ((new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    readonly disabled: BooleanConstructor;
+}, {
+    /**
+     * @description focus on current cell
+     */
+    focus: () => Promise<void | undefined>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly showWeekNumber: BooleanConstructor;
+    readonly selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<import("../props/shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<import("../props/shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly date: {
+        readonly type: import("vue").PropType<import("dayjs").Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | ((new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState) | ((new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    readonly disabled: BooleanConstructor;
+}>>, {
+    readonly disabled: boolean;
+    readonly showWeekNumber: boolean;
+    readonly rangeState: import("../props/shared").RangeState;
+    readonly selectionMode: string;
+}>;
+export default _default;

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-month-table.js

@@ -0,0 +1,237 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var basicMonthTable = require('../props/basic-month-table.js');
+var utils = require('../utils.js');
+var basicCellRender = require('./basic-cell-render.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+var index$1 = require('../../../../hooks/use-locale/index.js');
+var arrays = require('../../../../utils/arrays.js');
+var style = require('../../../../utils/dom/style.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "basic-month-table",
+  props: basicMonthTable.basicMonthTableProps,
+  emits: ["changerange", "pick", "select"],
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const ns = index.useNamespace("month-table");
+    const { t, lang } = index$1.useLocale();
+    const tbodyRef = vue.ref();
+    const currentCellRef = vue.ref();
+    const months = vue.ref(props.date.locale("en").localeData().monthsShort().map((_) => _.toLowerCase()));
+    const tableRows = vue.ref([[], [], []]);
+    const lastRow = vue.ref();
+    const lastColumn = vue.ref();
+    const rows = vue.computed(() => {
+      var _a, _b, _c;
+      const rows2 = tableRows.value;
+      const now = dayjs__default["default"]().locale(lang.value).startOf("month");
+      for (let i = 0; i < 3; i++) {
+        const row = rows2[i];
+        for (let j = 0; j < 4; j++) {
+          const cell = row[j] || (row[j] = {
+            row: i,
+            column: j,
+            type: "normal",
+            inRange: false,
+            start: false,
+            end: false,
+            text: -1,
+            disabled: false,
+            isSelected: false,
+            customClass: void 0,
+            date: void 0,
+            dayjs: void 0,
+            isCurrent: void 0,
+            selected: void 0,
+            renderText: void 0,
+            timestamp: void 0
+          });
+          cell.type = "normal";
+          const index = i * 4 + j;
+          const calTime = props.date.startOf("year").month(index);
+          const calEndDate = props.rangeState.endDate || props.maxDate || props.rangeState.selecting && props.minDate || null;
+          cell.inRange = !!(props.minDate && calTime.isSameOrAfter(props.minDate, "month") && calEndDate && calTime.isSameOrBefore(calEndDate, "month")) || !!(props.minDate && calTime.isSameOrBefore(props.minDate, "month") && calEndDate && calTime.isSameOrAfter(calEndDate, "month"));
+          if ((_a = props.minDate) == null ? void 0 : _a.isSameOrAfter(calEndDate)) {
+            cell.start = !!(calEndDate && calTime.isSame(calEndDate, "month"));
+            cell.end = props.minDate && calTime.isSame(props.minDate, "month");
+          } else {
+            cell.start = !!(props.minDate && calTime.isSame(props.minDate, "month"));
+            cell.end = !!(calEndDate && calTime.isSame(calEndDate, "month"));
+          }
+          const isToday = now.isSame(calTime);
+          if (isToday) {
+            cell.type = "today";
+          }
+          const cellDate = calTime.toDate();
+          cell.text = index;
+          cell.disabled = ((_b = props.disabledDate) == null ? void 0 : _b.call(props, cellDate)) || false;
+          cell.date = cellDate;
+          cell.customClass = (_c = props.cellClassName) == null ? void 0 : _c.call(props, cellDate);
+          cell.dayjs = calTime;
+          cell.timestamp = calTime.valueOf();
+          cell.isSelected = isSelectedCell(cell);
+        }
+      }
+      return rows2;
+    });
+    const focus = () => {
+      var _a;
+      (_a = currentCellRef.value) == null ? void 0 : _a.focus();
+    };
+    const getCellStyle = (cell) => {
+      const style = {};
+      const year = props.date.year();
+      const today = /* @__PURE__ */ new Date();
+      const month = cell.text;
+      style.disabled = props.disabled || (props.disabledDate ? utils.datesInMonth(props.date, year, month, lang.value).every(props.disabledDate) : false);
+      style.current = arrays.castArray(props.parsedValue).findIndex((date) => dayjs__default["default"].isDayjs(date) && date.year() === year && date.month() === month) >= 0;
+      style.today = today.getFullYear() === year && today.getMonth() === month;
+      if (cell.customClass) {
+        style[cell.customClass] = true;
+      }
+      if (cell.inRange) {
+        style["in-range"] = true;
+        if (cell.start) {
+          style["start-date"] = true;
+        }
+        if (cell.end) {
+          style["end-date"] = true;
+        }
+      }
+      return style;
+    };
+    const isSelectedCell = (cell) => {
+      const year = props.date.year();
+      const month = cell.text;
+      return arrays.castArray(props.date).findIndex((date) => date.year() === year && date.month() === month) >= 0;
+    };
+    const handleMouseMove = (event) => {
+      var _a;
+      if (!props.rangeState.selecting)
+        return;
+      let target = event.target;
+      if (target.tagName === "SPAN") {
+        target = (_a = target.parentNode) == null ? void 0 : _a.parentNode;
+      }
+      if (target.tagName === "DIV") {
+        target = target.parentNode;
+      }
+      if (target.tagName !== "TD")
+        return;
+      const row = target.parentNode.rowIndex;
+      const column = target.cellIndex;
+      if (rows.value[row][column].disabled)
+        return;
+      if (row !== lastRow.value || column !== lastColumn.value) {
+        lastRow.value = row;
+        lastColumn.value = column;
+        emit("changerange", {
+          selecting: true,
+          endDate: props.date.startOf("year").month(row * 4 + column)
+        });
+      }
+    };
+    const handleMonthTableClick = (event) => {
+      var _a;
+      if (props.disabled)
+        return;
+      const target = (_a = event.target) == null ? void 0 : _a.closest("td");
+      if ((target == null ? void 0 : target.tagName) !== "TD")
+        return;
+      if (style.hasClass(target, "disabled"))
+        return;
+      const column = target.cellIndex;
+      const row = target.parentNode.rowIndex;
+      const month = row * 4 + column;
+      const newDate = props.date.startOf("year").month(month);
+      if (props.selectionMode === "months") {
+        if (event.type === "keydown") {
+          emit("pick", arrays.castArray(props.parsedValue), false);
+          return;
+        }
+        const newMonth = utils.getValidDateOfMonth(props.date, props.date.year(), month, lang.value, props.disabledDate);
+        const newValue = style.hasClass(target, "current") ? arrays.castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.year()) !== newMonth.year() || (d == null ? void 0 : d.month()) !== newMonth.month()) : arrays.castArray(props.parsedValue).concat([dayjs__default["default"](newMonth)]);
+        emit("pick", newValue);
+      } else if (props.selectionMode === "range") {
+        if (!props.rangeState.selecting) {
+          emit("pick", { minDate: newDate, maxDate: null });
+          emit("select", true);
+        } else {
+          if (props.minDate && newDate >= props.minDate) {
+            emit("pick", { minDate: props.minDate, maxDate: newDate });
+          } else {
+            emit("pick", { minDate: newDate, maxDate: props.minDate });
+          }
+          emit("select", false);
+        }
+      } else {
+        emit("pick", month);
+      }
+    };
+    vue.watch(() => props.date, async () => {
+      var _a, _b;
+      if ((_a = tbodyRef.value) == null ? void 0 : _a.contains(document.activeElement)) {
+        await vue.nextTick();
+        (_b = currentCellRef.value) == null ? void 0 : _b.focus();
+      }
+    });
+    expose({
+      focus
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("table", {
+        role: "grid",
+        "aria-label": vue.unref(t)("el.datepicker.monthTablePrompt"),
+        class: vue.normalizeClass(vue.unref(ns).b()),
+        onClick: handleMonthTableClick,
+        onMousemove: handleMouseMove
+      }, [
+        vue.createElementVNode("tbody", {
+          ref_key: "tbodyRef",
+          ref: tbodyRef
+        }, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, key) => {
+            return vue.openBlock(), vue.createElementBlock("tr", { key }, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, key_) => {
+                return vue.openBlock(), vue.createElementBlock("td", {
+                  key: key_,
+                  ref_for: true,
+                  ref: (el) => cell.isSelected && (currentCellRef.value = el),
+                  class: vue.normalizeClass(getCellStyle(cell)),
+                  "aria-selected": !!cell.isSelected,
+                  "aria-label": vue.unref(t)(`el.datepicker.month${+cell.text + 1}`),
+                  tabindex: cell.isSelected ? 0 : -1,
+                  onKeydown: [
+                    vue.withKeys(vue.withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["space"]),
+                    vue.withKeys(vue.withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["enter"])
+                  ]
+                }, [
+                  vue.createVNode(vue.unref(basicCellRender["default"]), {
+                    cell: {
+                      ...cell,
+                      renderText: vue.unref(t)("el.datepicker.months." + months.value[cell.text])
+                    }
+                  }, null, 8, ["cell"])
+                ], 42, ["aria-selected", "aria-label", "tabindex", "onKeydown"]);
+              }), 128))
+            ]);
+          }), 128))
+        ], 512)
+      ], 42, ["aria-label"]);
+    };
+  }
+});
+var MonthTable = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "basic-month-table.vue"]]);
+
+exports["default"] = MonthTable;
+//# sourceMappingURL=basic-month-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-month-table.vue.d.ts

@@ -0,0 +1,106 @@
+import dayjs from 'dayjs';
+declare const _default: import("vue").DefineComponent<{
+    selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    cellClassName: {
+        readonly type: import("vue").PropType<import("../props/shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabledDate: {
+        readonly type: import("vue").PropType<import("../props/shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    date: {
+        readonly type: import("vue").PropType<dayjs.Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]) | ((new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState) | ((new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    disabled: BooleanConstructor;
+}, {
+    /**
+     * @description focus current cell
+     */
+    focus: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+    pick: (...args: any[]) => void;
+    changerange: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    cellClassName: {
+        readonly type: import("vue").PropType<import("../props/shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabledDate: {
+        readonly type: import("vue").PropType<import("../props/shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    date: {
+        readonly type: import("vue").PropType<dayjs.Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]) | ((new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState) | ((new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    disabled: BooleanConstructor;
+}>> & {
+    onSelect?: ((...args: any[]) => any) | undefined;
+    onPick?: ((...args: any[]) => any) | undefined;
+    onChangerange?: ((...args: any[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    rangeState: import("../props/shared").RangeState;
+    selectionMode: string;
+}>;
+export default _default;

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-year-table.js

@@ -0,0 +1,238 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var basicYearTable = require('../props/basic-year-table.js');
+var utils$1 = require('../utils.js');
+var basicCellRender = require('./basic-cell-render.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+var index$1 = require('../../../../hooks/use-locale/index.js');
+var arrays = require('../../../../utils/arrays.js');
+var utils = require('../../../time-picker/src/utils.js');
+var style = require('../../../../utils/dom/style.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "basic-year-table",
+  props: basicYearTable.basicYearTableProps,
+  emits: ["changerange", "pick", "select"],
+  setup(__props, { expose, emit }) {
+    const props = __props;
+    const datesInYear = (year, lang2) => {
+      const firstDay = dayjs__default["default"](String(year)).locale(lang2).startOf("year");
+      const lastDay = firstDay.endOf("year");
+      const numOfDays = lastDay.dayOfYear();
+      return utils.rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
+    };
+    const ns = index.useNamespace("year-table");
+    const { t, lang } = index$1.useLocale();
+    const tbodyRef = vue.ref();
+    const currentCellRef = vue.ref();
+    const startYear = vue.computed(() => {
+      return Math.floor(props.date.year() / 10) * 10;
+    });
+    const tableRows = vue.ref([[], [], []]);
+    const lastRow = vue.ref();
+    const lastColumn = vue.ref();
+    const rows = vue.computed(() => {
+      var _a, _b, _c;
+      const rows2 = tableRows.value;
+      const now = dayjs__default["default"]().locale(lang.value).startOf("year");
+      for (let i = 0; i < 3; i++) {
+        const row = rows2[i];
+        for (let j = 0; j < 4; j++) {
+          if (i * 4 + j >= 10) {
+            break;
+          }
+          let cell = row[j];
+          if (!cell) {
+            cell = {
+              row: i,
+              column: j,
+              type: "normal",
+              inRange: false,
+              start: false,
+              end: false,
+              text: -1,
+              disabled: false,
+              isSelected: false,
+              customClass: void 0,
+              date: void 0,
+              dayjs: void 0,
+              isCurrent: void 0,
+              selected: void 0,
+              renderText: void 0,
+              timestamp: void 0
+            };
+          }
+          cell.type = "normal";
+          const index = i * 4 + j + startYear.value;
+          const calTime = dayjs__default["default"]().year(index);
+          const calEndDate = props.rangeState.endDate || props.maxDate || props.rangeState.selecting && props.minDate || null;
+          cell.inRange = !!(props.minDate && calTime.isSameOrAfter(props.minDate, "year") && calEndDate && calTime.isSameOrBefore(calEndDate, "year")) || !!(props.minDate && calTime.isSameOrBefore(props.minDate, "year") && calEndDate && calTime.isSameOrAfter(calEndDate, "year"));
+          if ((_a = props.minDate) == null ? void 0 : _a.isSameOrAfter(calEndDate)) {
+            cell.start = !!(calEndDate && calTime.isSame(calEndDate, "year"));
+            cell.end = !!(props.minDate && calTime.isSame(props.minDate, "year"));
+          } else {
+            cell.start = !!(props.minDate && calTime.isSame(props.minDate, "year"));
+            cell.end = !!(calEndDate && calTime.isSame(calEndDate, "year"));
+          }
+          const isToday = now.isSame(calTime);
+          if (isToday) {
+            cell.type = "today";
+          }
+          cell.text = index;
+          const cellDate = calTime.toDate();
+          cell.disabled = ((_b = props.disabledDate) == null ? void 0 : _b.call(props, cellDate)) || false;
+          cell.date = cellDate;
+          cell.customClass = (_c = props.cellClassName) == null ? void 0 : _c.call(props, cellDate);
+          cell.dayjs = calTime;
+          cell.timestamp = calTime.valueOf();
+          cell.isSelected = isSelectedCell(cell);
+          row[j] = cell;
+        }
+      }
+      return rows2;
+    });
+    const focus = () => {
+      var _a;
+      (_a = currentCellRef.value) == null ? void 0 : _a.focus();
+    };
+    const getCellKls = (cell) => {
+      const kls = {};
+      const today = dayjs__default["default"]().locale(lang.value);
+      const year = cell.text;
+      kls.disabled = props.disabled || (props.disabledDate ? datesInYear(year, lang.value).every(props.disabledDate) : false);
+      kls.today = today.year() === year;
+      kls.current = arrays.castArray(props.parsedValue).findIndex((d) => d.year() === year) >= 0;
+      if (cell.customClass) {
+        kls[cell.customClass] = true;
+      }
+      if (cell.inRange) {
+        kls["in-range"] = true;
+        if (cell.start) {
+          kls["start-date"] = true;
+        }
+        if (cell.end) {
+          kls["end-date"] = true;
+        }
+      }
+      return kls;
+    };
+    const isSelectedCell = (cell) => {
+      const year = cell.text;
+      return arrays.castArray(props.date).findIndex((date) => date.year() === year) >= 0;
+    };
+    const handleYearTableClick = (event) => {
+      var _a;
+      if (props.disabled)
+        return;
+      const target = (_a = event.target) == null ? void 0 : _a.closest("td");
+      if (!target || !target.textContent || style.hasClass(target, "disabled"))
+        return;
+      const column = target.cellIndex;
+      const row = target.parentNode.rowIndex;
+      const selectedYear = row * 4 + column + startYear.value;
+      const newDate = dayjs__default["default"]().year(selectedYear);
+      if (props.selectionMode === "range") {
+        if (!props.rangeState.selecting) {
+          emit("pick", { minDate: newDate, maxDate: null });
+          emit("select", true);
+        } else {
+          if (props.minDate && newDate >= props.minDate) {
+            emit("pick", { minDate: props.minDate, maxDate: newDate });
+          } else {
+            emit("pick", { minDate: newDate, maxDate: props.minDate });
+          }
+          emit("select", false);
+        }
+      } else if (props.selectionMode === "years") {
+        if (event.type === "keydown") {
+          emit("pick", arrays.castArray(props.parsedValue), false);
+          return;
+        }
+        const vaildYear = utils$1.getValidDateOfYear(newDate.startOf("year"), lang.value, props.disabledDate);
+        const newValue = style.hasClass(target, "current") ? arrays.castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.year()) !== selectedYear) : arrays.castArray(props.parsedValue).concat([vaildYear]);
+        emit("pick", newValue);
+      } else {
+        emit("pick", selectedYear);
+      }
+    };
+    const handleMouseMove = (event) => {
+      var _a;
+      if (!props.rangeState.selecting)
+        return;
+      const target = (_a = event.target) == null ? void 0 : _a.closest("td");
+      if (!target)
+        return;
+      const row = target.parentNode.rowIndex;
+      const column = target.cellIndex;
+      if (rows.value[row][column].disabled)
+        return;
+      if (row !== lastRow.value || column !== lastColumn.value) {
+        lastRow.value = row;
+        lastColumn.value = column;
+        emit("changerange", {
+          selecting: true,
+          endDate: dayjs__default["default"]().year(startYear.value).add(row * 4 + column, "year")
+        });
+      }
+    };
+    vue.watch(() => props.date, async () => {
+      var _a, _b;
+      if ((_a = tbodyRef.value) == null ? void 0 : _a.contains(document.activeElement)) {
+        await vue.nextTick();
+        (_b = currentCellRef.value) == null ? void 0 : _b.focus();
+      }
+    });
+    expose({
+      focus
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("table", {
+        role: "grid",
+        "aria-label": vue.unref(t)("el.datepicker.yearTablePrompt"),
+        class: vue.normalizeClass(vue.unref(ns).b()),
+        onClick: handleYearTableClick,
+        onMousemove: handleMouseMove
+      }, [
+        vue.createElementVNode("tbody", {
+          ref_key: "tbodyRef",
+          ref: tbodyRef
+        }, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, rowKey) => {
+            return vue.openBlock(), vue.createElementBlock("tr", { key: rowKey }, [
+              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, cellKey) => {
+                return vue.openBlock(), vue.createElementBlock("td", {
+                  key: `${rowKey}_${cellKey}`,
+                  ref_for: true,
+                  ref: (el) => cell.isSelected && (currentCellRef.value = el),
+                  class: vue.normalizeClass(["available", getCellKls(cell)]),
+                  "aria-selected": cell.isSelected,
+                  "aria-label": String(cell.text),
+                  tabindex: cell.isSelected ? 0 : -1,
+                  onKeydown: [
+                    vue.withKeys(vue.withModifiers(handleYearTableClick, ["prevent", "stop"]), ["space"]),
+                    vue.withKeys(vue.withModifiers(handleYearTableClick, ["prevent", "stop"]), ["enter"])
+                  ]
+                }, [
+                  vue.createVNode(vue.unref(basicCellRender["default"]), { cell }, null, 8, ["cell"])
+                ], 42, ["aria-selected", "aria-label", "tabindex", "onKeydown"]);
+              }), 128))
+            ]);
+          }), 128))
+        ], 512)
+      ], 42, ["aria-label"]);
+    };
+  }
+});
+var YearTable = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "basic-year-table.vue"]]);
+
+exports["default"] = YearTable;
+//# sourceMappingURL=basic-year-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-com/basic-year-table.vue.d.ts

@@ -0,0 +1,106 @@
+import dayjs from 'dayjs';
+declare const _default: import("vue").DefineComponent<{
+    readonly selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<import("../props/shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<import("../props/shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly date: {
+        readonly type: import("vue").PropType<dayjs.Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]) | ((new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState) | ((new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    readonly disabled: BooleanConstructor;
+}, {
+    /**
+     * @description focus on the current cell
+     */
+    focus: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    select: (...args: any[]) => void;
+    pick: (...args: any[]) => void;
+    changerange: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<import("../props/shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<import("../props/shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly date: {
+        readonly type: import("vue").PropType<dayjs.Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null) | ((new (...args: any[]) => dayjs.Dayjs) | (() => dayjs.Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]) | ((new (...args: any[]) => dayjs.Dayjs | dayjs.Dayjs[]) | (() => dayjs.Dayjs | dayjs.Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState) | ((new (...args: any[]) => import("../props/shared").RangeState) | (() => import("../props/shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    readonly disabled: BooleanConstructor;
+}>> & {
+    onSelect?: ((...args: any[]) => any) | undefined;
+    onPick?: ((...args: any[]) => any) | undefined;
+    onChangerange?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly rangeState: import("../props/shared").RangeState;
+    readonly selectionMode: string;
+}>;
+export default _default;

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

@@ -0,0 +1,723 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var index$5 = require('../../../button/index.js');
+var index$2 = require('../../../input/index.js');
+require('../../../time-picker/index.js');
+var index$4 = require('../../../icon/index.js');
+var iconsVue = require('@element-plus/icons-vue');
+var panelDatePick = require('../props/panel-date-pick.js');
+var utils$1 = require('../utils.js');
+var constants$1 = require('../constants.js');
+var basicDateTable = require('./basic-date-table.js');
+var basicMonthTable = require('./basic-month-table.js');
+var basicYearTable = require('./basic-year-table.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+var constants = require('../../../time-picker/src/constants.js');
+var utils = require('../../../time-picker/src/utils.js');
+var arrays = require('../../../../utils/arrays.js');
+var panelTimePick = require('../../../time-picker/src/time-picker-com/panel-time-pick.js');
+var index$3 = require('../../../../directives/click-outside/index.js');
+var index = require('../../../../hooks/use-namespace/index.js');
+var index$1 = require('../../../../hooks/use-locale/index.js');
+var shared = require('@vue/shared');
+var aria = require('../../../../constants/aria.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "panel-date-pick",
+  props: panelDatePick.panelDatePickProps,
+  emits: ["pick", "set-picker-option", "panel-change"],
+  setup(__props, { emit: contextEmit }) {
+    const props = __props;
+    const timeWithinRange = (_, __, ___) => true;
+    const ppNs = index.useNamespace("picker-panel");
+    const dpNs = index.useNamespace("date-picker");
+    const attrs = vue.useAttrs();
+    const slots = vue.useSlots();
+    const { t, lang } = index$1.useLocale();
+    const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
+    const isDefaultFormat = vue.inject(constants$1.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
+    const { shortcuts, disabledDate, cellClassName, defaultTime } = pickerBase.props;
+    const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
+    const currentViewRef = vue.ref();
+    const innerDate = vue.ref(dayjs__default["default"]().locale(lang.value));
+    const isChangeToNow = vue.ref(false);
+    let isShortcut = false;
+    const defaultTimeD = vue.computed(() => {
+      return dayjs__default["default"](defaultTime).locale(lang.value);
+    });
+    const month = vue.computed(() => {
+      return innerDate.value.month();
+    });
+    const year = vue.computed(() => {
+      return innerDate.value.year();
+    });
+    const selectableRange = vue.ref([]);
+    const userInputDate = vue.ref(null);
+    const userInputTime = vue.ref(null);
+    const checkDateWithinRange = (date) => {
+      return selectableRange.value.length > 0 ? timeWithinRange(date, selectableRange.value, props.format || "HH:mm:ss") : true;
+    };
+    const formatEmit = (emitDayjs) => {
+      if (defaultTime && !visibleTime.value && !isChangeToNow.value && !isShortcut) {
+        return defaultTimeD.value.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
+      }
+      if (showTime.value)
+        return emitDayjs.millisecond(0);
+      return emitDayjs.startOf("day");
+    };
+    const emit = (value, ...args) => {
+      if (!value) {
+        contextEmit("pick", value, ...args);
+      } else if (shared.isArray(value)) {
+        const dates = value.map(formatEmit);
+        contextEmit("pick", dates, ...args);
+      } else {
+        contextEmit("pick", formatEmit(value), ...args);
+      }
+      userInputDate.value = null;
+      userInputTime.value = null;
+      isChangeToNow.value = false;
+      isShortcut = false;
+    };
+    const handleDatePick = async (value, keepOpen) => {
+      if (selectionMode.value === "date" && dayjs__default["default"].isDayjs(value)) {
+        const parsedDateValue = arrays.extractFirst(props.parsedValue);
+        let newDate = parsedDateValue ? parsedDateValue.year(value.year()).month(value.month()).date(value.date()) : value;
+        if (!checkDateWithinRange(newDate)) {
+          newDate = selectableRange.value[0][0].year(value.year()).month(value.month()).date(value.date());
+        }
+        innerDate.value = newDate;
+        emit(newDate, showTime.value || keepOpen);
+      } else if (selectionMode.value === "week") {
+        emit(value.date);
+      } else if (selectionMode.value === "dates") {
+        emit(value, true);
+      }
+    };
+    const moveByMonth = (forward) => {
+      const action = forward ? "add" : "subtract";
+      innerDate.value = innerDate.value[action](1, "month");
+      handlePanelChange("month");
+    };
+    const moveByYear = (forward) => {
+      const currentDate = innerDate.value;
+      const action = forward ? "add" : "subtract";
+      innerDate.value = currentView.value === "year" ? currentDate[action](10, "year") : currentDate[action](1, "year");
+      handlePanelChange("year");
+    };
+    const currentView = vue.ref("date");
+    const yearLabel = vue.computed(() => {
+      const yearTranslation = t("el.datepicker.year");
+      if (currentView.value === "year") {
+        const startYear = Math.floor(year.value / 10) * 10;
+        if (yearTranslation) {
+          return `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}`;
+        }
+        return `${startYear} - ${startYear + 9}`;
+      }
+      return `${year.value} ${yearTranslation}`;
+    });
+    const handleShortcutClick = (shortcut) => {
+      const shortcutValue = shared.isFunction(shortcut.value) ? shortcut.value() : shortcut.value;
+      if (shortcutValue) {
+        isShortcut = true;
+        emit(dayjs__default["default"](shortcutValue).locale(lang.value));
+        return;
+      }
+      if (shortcut.onClick) {
+        shortcut.onClick({
+          attrs,
+          slots,
+          emit: contextEmit
+        });
+      }
+    };
+    const selectionMode = vue.computed(() => {
+      const { type } = props;
+      if (["week", "month", "months", "year", "years", "dates"].includes(type))
+        return type;
+      return "date";
+    });
+    const isMultipleType = vue.computed(() => {
+      return selectionMode.value === "dates" || selectionMode.value === "months" || selectionMode.value === "years";
+    });
+    const keyboardMode = vue.computed(() => {
+      return selectionMode.value === "date" ? currentView.value : selectionMode.value;
+    });
+    const hasShortcuts = vue.computed(() => !!shortcuts.length);
+    const handleMonthPick = async (month2, keepOpen) => {
+      if (selectionMode.value === "month") {
+        innerDate.value = utils$1.getValidDateOfMonth(innerDate.value, innerDate.value.year(), month2, lang.value, disabledDate);
+        emit(innerDate.value, false);
+      } else if (selectionMode.value === "months") {
+        emit(month2, keepOpen != null ? keepOpen : true);
+      } else {
+        innerDate.value = utils$1.getValidDateOfMonth(innerDate.value, innerDate.value.year(), month2, lang.value, disabledDate);
+        currentView.value = "date";
+        if (["month", "year", "date", "week"].includes(selectionMode.value)) {
+          emit(innerDate.value, true);
+          await vue.nextTick();
+          handleFocusPicker();
+        }
+      }
+      handlePanelChange("month");
+    };
+    const handleYearPick = async (year2, keepOpen) => {
+      if (selectionMode.value === "year") {
+        const data = innerDate.value.startOf("year").year(year2);
+        innerDate.value = utils$1.getValidDateOfYear(data, lang.value, disabledDate);
+        emit(innerDate.value, false);
+      } else if (selectionMode.value === "years") {
+        emit(year2, keepOpen != null ? keepOpen : true);
+      } else {
+        const data = innerDate.value.year(year2);
+        innerDate.value = utils$1.getValidDateOfYear(data, lang.value, disabledDate);
+        currentView.value = "month";
+        if (["month", "year", "date", "week"].includes(selectionMode.value)) {
+          emit(innerDate.value, true);
+          await vue.nextTick();
+          handleFocusPicker();
+        }
+      }
+      handlePanelChange("year");
+    };
+    const showPicker = async (view) => {
+      if (props.disabled)
+        return;
+      currentView.value = view;
+      await vue.nextTick();
+      handleFocusPicker();
+    };
+    const showTime = vue.computed(() => props.type === "datetime" || props.type === "datetimerange");
+    const footerVisible = vue.computed(() => {
+      const showDateFooter = showTime.value || selectionMode.value === "dates";
+      const showYearFooter = selectionMode.value === "years";
+      const showMonthFooter = selectionMode.value === "months";
+      const isDateView = currentView.value === "date";
+      const isYearView = currentView.value === "year";
+      const isMonthView = currentView.value === "month";
+      return showDateFooter && isDateView || showYearFooter && isYearView || showMonthFooter && isMonthView;
+    });
+    const footerFilled = vue.computed(() => !isMultipleType.value && props.showNow || props.showConfirm);
+    const disabledConfirm = vue.computed(() => {
+      if (!disabledDate)
+        return false;
+      if (!props.parsedValue)
+        return true;
+      if (shared.isArray(props.parsedValue)) {
+        return disabledDate(props.parsedValue[0].toDate());
+      }
+      return disabledDate(props.parsedValue.toDate());
+    });
+    const onConfirm = () => {
+      if (isMultipleType.value) {
+        emit(props.parsedValue);
+      } else {
+        let result = arrays.extractFirst(props.parsedValue);
+        if (!result) {
+          const defaultTimeD2 = dayjs__default["default"](defaultTime).locale(lang.value);
+          const defaultValueD = getDefaultValue();
+          result = defaultTimeD2.year(defaultValueD.year()).month(defaultValueD.month()).date(defaultValueD.date());
+        }
+        innerDate.value = result;
+        emit(result);
+      }
+    };
+    const disabledNow = vue.computed(() => {
+      if (!disabledDate)
+        return false;
+      return disabledDate(dayjs__default["default"]().locale(lang.value).toDate());
+    });
+    const changeToNow = () => {
+      const now = dayjs__default["default"]().locale(lang.value);
+      const nowDate = now.toDate();
+      isChangeToNow.value = true;
+      if ((!disabledDate || !disabledDate(nowDate)) && checkDateWithinRange(nowDate)) {
+        innerDate.value = dayjs__default["default"]().locale(lang.value);
+        emit(innerDate.value);
+      }
+    };
+    const timeFormat = vue.computed(() => {
+      return props.timeFormat || utils.extractTimeFormat(props.format) || constants.DEFAULT_FORMATS_TIME;
+    });
+    const dateFormat = vue.computed(() => {
+      return props.dateFormat || utils.extractDateFormat(props.format) || constants.DEFAULT_FORMATS_DATE;
+    });
+    const visibleTime = vue.computed(() => {
+      if (userInputTime.value)
+        return userInputTime.value;
+      if (!props.parsedValue && !defaultValue.value)
+        return;
+      const dateValue = arrays.extractFirst(props.parsedValue) || innerDate.value;
+      return dateValue.format(timeFormat.value);
+    });
+    const visibleDate = vue.computed(() => {
+      if (userInputDate.value)
+        return userInputDate.value;
+      if (!props.parsedValue && !defaultValue.value)
+        return;
+      const dateValue = arrays.extractFirst(props.parsedValue) || innerDate.value;
+      return dateValue.format(dateFormat.value);
+    });
+    const timePickerVisible = vue.ref(false);
+    const onTimePickerInputFocus = () => {
+      timePickerVisible.value = true;
+    };
+    const handleTimePickClose = () => {
+      timePickerVisible.value = false;
+    };
+    const getUnits = (date) => {
+      return {
+        hour: date.hour(),
+        minute: date.minute(),
+        second: date.second(),
+        year: date.year(),
+        month: date.month(),
+        date: date.date()
+      };
+    };
+    const handleTimePick = (value, visible, first) => {
+      const { hour, minute, second } = getUnits(value);
+      const parsedDateValue = arrays.extractFirst(props.parsedValue);
+      const newDate = parsedDateValue ? parsedDateValue.hour(hour).minute(minute).second(second) : value;
+      innerDate.value = newDate;
+      emit(innerDate.value, true);
+      if (!first) {
+        timePickerVisible.value = visible;
+      }
+    };
+    const handleVisibleTimeChange = (value) => {
+      const newDate = dayjs__default["default"](value, timeFormat.value).locale(lang.value);
+      if (newDate.isValid() && checkDateWithinRange(newDate)) {
+        const { year: year2, month: month2, date } = getUnits(innerDate.value);
+        innerDate.value = newDate.year(year2).month(month2).date(date);
+        userInputTime.value = null;
+        timePickerVisible.value = false;
+        emit(innerDate.value, true);
+      }
+    };
+    const handleVisibleDateChange = (value) => {
+      const newDate = utils$1.correctlyParseUserInput(value, dateFormat.value, lang.value, isDefaultFormat);
+      if (newDate.isValid()) {
+        if (disabledDate && disabledDate(newDate.toDate())) {
+          return;
+        }
+        const { hour, minute, second } = getUnits(innerDate.value);
+        innerDate.value = newDate.hour(hour).minute(minute).second(second);
+        userInputDate.value = null;
+        emit(innerDate.value, true);
+      }
+    };
+    const isValidValue = (date) => {
+      return dayjs__default["default"].isDayjs(date) && date.isValid() && (disabledDate ? !disabledDate(date.toDate()) : true);
+    };
+    const formatToString = (value) => {
+      return shared.isArray(value) ? value.map((_) => _.format(props.format)) : value.format(props.format);
+    };
+    const parseUserInput = (value) => {
+      return utils$1.correctlyParseUserInput(value, props.format, lang.value, isDefaultFormat);
+    };
+    const getDefaultValue = () => {
+      const parseDate = dayjs__default["default"](defaultValue.value).locale(lang.value);
+      if (!defaultValue.value) {
+        const defaultTimeDValue = defaultTimeD.value;
+        return dayjs__default["default"]().hour(defaultTimeDValue.hour()).minute(defaultTimeDValue.minute()).second(defaultTimeDValue.second()).locale(lang.value);
+      }
+      return parseDate;
+    };
+    const handleFocusPicker = () => {
+      var _a;
+      if (["week", "month", "year", "date"].includes(selectionMode.value)) {
+        (_a = currentViewRef.value) == null ? void 0 : _a.focus();
+      }
+    };
+    const _handleFocusPicker = () => {
+      handleFocusPicker();
+      if (selectionMode.value === "week") {
+        handleKeyControl(aria.EVENT_CODE.down);
+      }
+    };
+    const handleKeydownTable = (event) => {
+      const { code } = event;
+      const validCode = [
+        aria.EVENT_CODE.up,
+        aria.EVENT_CODE.down,
+        aria.EVENT_CODE.left,
+        aria.EVENT_CODE.right,
+        aria.EVENT_CODE.home,
+        aria.EVENT_CODE.end,
+        aria.EVENT_CODE.pageUp,
+        aria.EVENT_CODE.pageDown
+      ];
+      if (validCode.includes(code)) {
+        handleKeyControl(code);
+        event.stopPropagation();
+        event.preventDefault();
+      }
+      if ([aria.EVENT_CODE.enter, aria.EVENT_CODE.space, aria.EVENT_CODE.numpadEnter].includes(code) && userInputDate.value === null && userInputTime.value === null) {
+        event.preventDefault();
+        emit(innerDate.value, false);
+      }
+    };
+    const handleKeyControl = (code) => {
+      var _a;
+      const { up, down, left, right, home, end, pageUp, pageDown } = aria.EVENT_CODE;
+      const mapping = {
+        year: {
+          [up]: -4,
+          [down]: 4,
+          [left]: -1,
+          [right]: 1,
+          offset: (date, step) => date.setFullYear(date.getFullYear() + step)
+        },
+        month: {
+          [up]: -4,
+          [down]: 4,
+          [left]: -1,
+          [right]: 1,
+          offset: (date, step) => date.setMonth(date.getMonth() + step)
+        },
+        week: {
+          [up]: -1,
+          [down]: 1,
+          [left]: -1,
+          [right]: 1,
+          offset: (date, step) => date.setDate(date.getDate() + step * 7)
+        },
+        date: {
+          [up]: -7,
+          [down]: 7,
+          [left]: -1,
+          [right]: 1,
+          [home]: (date) => -date.getDay(),
+          [end]: (date) => -date.getDay() + 6,
+          [pageUp]: (date) => -new Date(date.getFullYear(), date.getMonth(), 0).getDate(),
+          [pageDown]: (date) => new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate(),
+          offset: (date, step) => date.setDate(date.getDate() + step)
+        }
+      };
+      const newDate = innerDate.value.toDate();
+      while (Math.abs(innerDate.value.diff(newDate, "year", true)) < 1) {
+        const map = mapping[keyboardMode.value];
+        if (!map)
+          return;
+        map.offset(newDate, shared.isFunction(map[code]) ? map[code](newDate) : (_a = map[code]) != null ? _a : 0);
+        if (disabledDate && disabledDate(newDate)) {
+          break;
+        }
+        const result = dayjs__default["default"](newDate).locale(lang.value);
+        innerDate.value = result;
+        contextEmit("pick", result, true);
+        break;
+      }
+    };
+    const handlePanelChange = (mode) => {
+      contextEmit("panel-change", innerDate.value.toDate(), mode, currentView.value);
+    };
+    vue.watch(() => selectionMode.value, (val) => {
+      if (["month", "year"].includes(val)) {
+        currentView.value = val;
+        return;
+      } else if (val === "years") {
+        currentView.value = "year";
+        return;
+      } else if (val === "months") {
+        currentView.value = "month";
+        return;
+      }
+      currentView.value = "date";
+    }, { immediate: true });
+    vue.watch(() => defaultValue.value, (val) => {
+      if (val) {
+        innerDate.value = getDefaultValue();
+      }
+    }, { immediate: true });
+    vue.watch(() => props.parsedValue, (val) => {
+      if (val) {
+        if (isMultipleType.value)
+          return;
+        if (shared.isArray(val))
+          return;
+        innerDate.value = val;
+      } else {
+        innerDate.value = getDefaultValue();
+      }
+    }, { immediate: true });
+    contextEmit("set-picker-option", ["isValidValue", isValidValue]);
+    contextEmit("set-picker-option", ["formatToString", formatToString]);
+    contextEmit("set-picker-option", ["parseUserInput", parseUserInput]);
+    contextEmit("set-picker-option", ["handleFocusPicker", _handleFocusPicker]);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([
+          vue.unref(ppNs).b(),
+          vue.unref(dpNs).b(),
+          vue.unref(ppNs).is("border", _ctx.border),
+          vue.unref(ppNs).is("disabled", _ctx.disabled),
+          {
+            "has-sidebar": _ctx.$slots.sidebar || vue.unref(hasShortcuts),
+            "has-time": vue.unref(showTime)
+          }
+        ])
+      }, [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
+        }, [
+          vue.renderSlot(_ctx.$slots, "sidebar", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }),
+          vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
+              return vue.openBlock(), vue.createElementBlock("button", {
+                key,
+                type: "button",
+                disabled: _ctx.disabled,
+                class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
+                onClick: ($event) => handleShortcutClick(shortcut)
+              }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
+            }), 128))
+          ], 2)) : vue.createCommentVNode("v-if", true),
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("body"))
+          }, [
+            vue.unref(showTime) ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              class: vue.normalizeClass(vue.unref(dpNs).e("time-header"))
+            }, [
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass(vue.unref(dpNs).e("editor-wrap"))
+              }, [
+                vue.createVNode(vue.unref(index$2.ElInput), {
+                  placeholder: vue.unref(t)("el.datepicker.selectDate"),
+                  "model-value": vue.unref(visibleDate),
+                  size: "small",
+                  "validate-event": false,
+                  disabled: _ctx.disabled,
+                  onInput: (val) => userInputDate.value = val,
+                  onChange: handleVisibleDateChange
+                }, null, 8, ["placeholder", "model-value", "disabled", "onInput"])
+              ], 2),
+              vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
+                class: vue.normalizeClass(vue.unref(dpNs).e("editor-wrap"))
+              }, [
+                vue.createVNode(vue.unref(index$2.ElInput), {
+                  placeholder: vue.unref(t)("el.datepicker.selectTime"),
+                  "model-value": vue.unref(visibleTime),
+                  size: "small",
+                  "validate-event": false,
+                  disabled: _ctx.disabled,
+                  onFocus: onTimePickerInputFocus,
+                  onInput: (val) => userInputTime.value = val,
+                  onChange: handleVisibleTimeChange
+                }, null, 8, ["placeholder", "model-value", "disabled", "onInput"]),
+                vue.createVNode(vue.unref(panelTimePick["default"]), {
+                  visible: timePickerVisible.value,
+                  format: vue.unref(timeFormat),
+                  "parsed-value": innerDate.value,
+                  onPick: handleTimePick
+                }, null, 8, ["visible", "format", "parsed-value"])
+              ], 2)), [
+                [vue.unref(index$3["default"]), handleTimePickClose]
+              ])
+            ], 2)) : vue.createCommentVNode("v-if", true),
+            vue.withDirectives(vue.createElementVNode("div", {
+              class: vue.normalizeClass([
+                vue.unref(dpNs).e("header"),
+                (currentView.value === "year" || currentView.value === "month") && vue.unref(dpNs).e("header--bordered")
+              ])
+            }, [
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass(vue.unref(dpNs).e("prev-btn"))
+              }, [
+                vue.createElementVNode("button", {
+                  type: "button",
+                  "aria-label": vue.unref(t)(`el.datepicker.prevYear`),
+                  class: vue.normalizeClass(["d-arrow-left", vue.unref(ppNs).e("icon-btn")]),
+                  disabled: _ctx.disabled,
+                  onClick: ($event) => moveByYear(false)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
+                    vue.createVNode(vue.unref(index$4.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["aria-label", "disabled", "onClick"]),
+                vue.withDirectives(vue.createElementVNode("button", {
+                  type: "button",
+                  "aria-label": vue.unref(t)(`el.datepicker.prevMonth`),
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
+                  disabled: _ctx.disabled,
+                  onClick: ($event) => moveByMonth(false)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-month", {}, () => [
+                    vue.createVNode(vue.unref(index$4.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.ArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["aria-label", "disabled", "onClick"]), [
+                  [vue.vShow, currentView.value === "date"]
+                ])
+              ], 2),
+              vue.createElementVNode("span", {
+                role: "button",
+                class: vue.normalizeClass(vue.unref(dpNs).e("header-label")),
+                "aria-live": "polite",
+                tabindex: "0",
+                onKeydown: vue.withKeys(($event) => showPicker("year"), ["enter"]),
+                onClick: ($event) => showPicker("year")
+              }, vue.toDisplayString(vue.unref(yearLabel)), 43, ["onKeydown", "onClick"]),
+              vue.withDirectives(vue.createElementVNode("span", {
+                role: "button",
+                "aria-live": "polite",
+                tabindex: "0",
+                class: vue.normalizeClass([
+                  vue.unref(dpNs).e("header-label"),
+                  { active: currentView.value === "month" }
+                ]),
+                onKeydown: vue.withKeys(($event) => showPicker("month"), ["enter"]),
+                onClick: ($event) => showPicker("month")
+              }, vue.toDisplayString(vue.unref(t)(`el.datepicker.month${vue.unref(month) + 1}`)), 43, ["onKeydown", "onClick"]), [
+                [vue.vShow, currentView.value === "date"]
+              ]),
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass(vue.unref(dpNs).e("next-btn"))
+              }, [
+                vue.withDirectives(vue.createElementVNode("button", {
+                  type: "button",
+                  "aria-label": vue.unref(t)(`el.datepicker.nextMonth`),
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-right"]),
+                  disabled: _ctx.disabled,
+                  onClick: ($event) => moveByMonth(true)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-month", {}, () => [
+                    vue.createVNode(vue.unref(index$4.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.ArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["aria-label", "disabled", "onClick"]), [
+                  [vue.vShow, currentView.value === "date"]
+                ]),
+                vue.createElementVNode("button", {
+                  type: "button",
+                  "aria-label": vue.unref(t)(`el.datepicker.nextYear`),
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
+                  disabled: _ctx.disabled,
+                  onClick: ($event) => moveByYear(true)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
+                    vue.createVNode(vue.unref(index$4.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["aria-label", "disabled", "onClick"])
+              ], 2)
+            ], 2), [
+              [vue.vShow, currentView.value !== "time"]
+            ]),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(vue.unref(ppNs).e("content")),
+              onKeydown: handleKeydownTable
+            }, [
+              currentView.value === "date" ? (vue.openBlock(), vue.createBlock(basicDateTable["default"], {
+                key: 0,
+                ref_key: "currentViewRef",
+                ref: currentViewRef,
+                "selection-mode": vue.unref(selectionMode),
+                date: innerDate.value,
+                "parsed-value": _ctx.parsedValue,
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                "cell-class-name": vue.unref(cellClassName),
+                "show-week-number": _ctx.showWeekNumber,
+                onPick: handleDatePick
+              }, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date", "disabled", "cell-class-name", "show-week-number"])) : vue.createCommentVNode("v-if", true),
+              currentView.value === "year" ? (vue.openBlock(), vue.createBlock(basicYearTable["default"], {
+                key: 1,
+                ref_key: "currentViewRef",
+                ref: currentViewRef,
+                "selection-mode": vue.unref(selectionMode),
+                date: innerDate.value,
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                "parsed-value": _ctx.parsedValue,
+                "cell-class-name": vue.unref(cellClassName),
+                onPick: handleYearPick
+              }, null, 8, ["selection-mode", "date", "disabled-date", "disabled", "parsed-value", "cell-class-name"])) : vue.createCommentVNode("v-if", true),
+              currentView.value === "month" ? (vue.openBlock(), vue.createBlock(basicMonthTable["default"], {
+                key: 2,
+                ref_key: "currentViewRef",
+                ref: currentViewRef,
+                "selection-mode": vue.unref(selectionMode),
+                date: innerDate.value,
+                "parsed-value": _ctx.parsedValue,
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                "cell-class-name": vue.unref(cellClassName),
+                onPick: handleMonthPick
+              }, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date", "disabled", "cell-class-name"])) : vue.createCommentVNode("v-if", true)
+            ], 34)
+          ], 2)
+        ], 2),
+        _ctx.showFooter && vue.unref(footerVisible) && vue.unref(footerFilled) ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: vue.normalizeClass(vue.unref(ppNs).e("footer"))
+        }, [
+          vue.withDirectives(vue.createVNode(vue.unref(index$5.ElButton), {
+            text: "",
+            size: "small",
+            class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
+            disabled: vue.unref(disabledNow),
+            onClick: changeToNow
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.now")), 1)
+            ]),
+            _: 1
+          }, 8, ["class", "disabled"]), [
+            [vue.vShow, !vue.unref(isMultipleType) && _ctx.showNow]
+          ]),
+          _ctx.showConfirm ? (vue.openBlock(), vue.createBlock(vue.unref(index$5.ElButton), {
+            key: 0,
+            plain: "",
+            size: "small",
+            class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
+            disabled: vue.unref(disabledConfirm),
+            onClick: onConfirm
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 1)
+            ]),
+            _: 1
+          }, 8, ["class", "disabled"])) : vue.createCommentVNode("v-if", true)
+        ], 2)) : vue.createCommentVNode("v-if", true)
+      ], 2);
+    };
+  }
+});
+var DatePickPanel = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "panel-date-pick.vue"]]);
+
+exports["default"] = DatePickPanel;
+//# sourceMappingURL=panel-date-pick.js.map

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

@@ -0,0 +1,81 @@
+import dayjs from 'dayjs';
+declare function __VLS_template(): {
+    sidebar?(_: {
+        class: string;
+    }): any;
+    "prev-year"?(_: {}): any;
+    "prev-month"?(_: {}): any;
+    "next-month"?(_: {}): any;
+    "next-year"?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "panel-change": (...args: any[]) => void;
+    pick: (...args: any[]) => void;
+    "set-picker-option": (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+}>> & {
+    onPick?: ((...args: any[]) => any) | undefined;
+    "onPanel-change"?: ((...args: any[]) => any) | undefined;
+    "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly border: boolean;
+    readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly format: string;
+    readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showWeekNumber: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,831 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var index$4 = require('../../../button/index.js');
+var index$1 = require('../../../input/index.js');
+require('../../../time-picker/index.js');
+var index$3 = require('../../../icon/index.js');
+var iconsVue = require('@element-plus/icons-vue');
+var panelDateRange = require('../props/panel-date-range.js');
+var useRangePicker = require('../composables/use-range-picker.js');
+var utils$1 = require('../utils.js');
+var usePanelDateRange = require('../composables/use-panel-date-range.js');
+var constants$1 = require('../constants.js');
+var basicYearTable = require('./basic-year-table.js');
+var basicMonthTable = require('./basic-month-table.js');
+var basicDateTable = require('./basic-date-table.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+var panelTimePick = require('../../../time-picker/src/time-picker-com/panel-time-pick.js');
+var index$2 = require('../../../../directives/click-outside/index.js');
+var constants = require('../../../time-picker/src/constants.js');
+var index = require('../../../../hooks/use-locale/index.js');
+var utils = require('../../../time-picker/src/utils.js');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const unit = "month";
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "panel-date-range",
+  props: panelDateRange.panelDateRangeProps,
+  emits: [
+    "pick",
+    "set-picker-option",
+    "calendar-change",
+    "panel-change"
+  ],
+  setup(__props, { emit }) {
+    const props = __props;
+    const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
+    const isDefaultFormat = vue.inject(constants$1.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
+    const { disabledDate, cellClassName, defaultTime, clearable } = pickerBase.props;
+    const format = vue.toRef(pickerBase.props, "format");
+    const shortcuts = vue.toRef(pickerBase.props, "shortcuts");
+    const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
+    const { lang } = index.useLocale();
+    const leftDate = vue.ref(dayjs__default["default"]().locale(lang.value));
+    const rightDate = vue.ref(dayjs__default["default"]().locale(lang.value).add(1, unit));
+    const {
+      minDate,
+      maxDate,
+      rangeState,
+      ppNs,
+      drpNs,
+      handleChangeRange,
+      handleRangeConfirm,
+      handleShortcutClick,
+      onSelect,
+      parseValue,
+      t
+    } = useRangePicker.useRangePicker(props, {
+      defaultValue,
+      defaultTime,
+      leftDate,
+      rightDate,
+      unit,
+      sortDates
+    });
+    vue.watch(() => props.visible, (visible) => {
+      if (!visible && rangeState.value.selecting) {
+        parseValue(props.parsedValue);
+        onSelect(false);
+      }
+    });
+    const dateUserInput = vue.ref({
+      min: null,
+      max: null
+    });
+    const timeUserInput = vue.ref({
+      min: null,
+      max: null
+    });
+    const {
+      leftCurrentView,
+      rightCurrentView,
+      leftCurrentViewRef,
+      rightCurrentViewRef,
+      leftYear,
+      rightYear,
+      leftMonth,
+      rightMonth,
+      leftYearLabel,
+      rightYearLabel,
+      showLeftPicker,
+      showRightPicker,
+      handleLeftYearPick,
+      handleRightYearPick,
+      handleLeftMonthPick,
+      handleRightMonthPick,
+      handlePanelChange,
+      adjustDateByView
+    } = usePanelDateRange.usePanelDateRange(props, emit, leftDate, rightDate);
+    const hasShortcuts = vue.computed(() => !!shortcuts.value.length);
+    const minVisibleDate = vue.computed(() => {
+      if (dateUserInput.value.min !== null)
+        return dateUserInput.value.min;
+      if (minDate.value)
+        return minDate.value.format(dateFormat.value);
+      return "";
+    });
+    const maxVisibleDate = vue.computed(() => {
+      if (dateUserInput.value.max !== null)
+        return dateUserInput.value.max;
+      if (maxDate.value || minDate.value)
+        return (maxDate.value || minDate.value).format(dateFormat.value);
+      return "";
+    });
+    const minVisibleTime = vue.computed(() => {
+      if (timeUserInput.value.min !== null)
+        return timeUserInput.value.min;
+      if (minDate.value)
+        return minDate.value.format(timeFormat.value);
+      return "";
+    });
+    const maxVisibleTime = vue.computed(() => {
+      if (timeUserInput.value.max !== null)
+        return timeUserInput.value.max;
+      if (maxDate.value || minDate.value)
+        return (maxDate.value || minDate.value).format(timeFormat.value);
+      return "";
+    });
+    const timeFormat = vue.computed(() => {
+      return props.timeFormat || utils.extractTimeFormat(format.value || "") || constants.DEFAULT_FORMATS_TIME;
+    });
+    const dateFormat = vue.computed(() => {
+      return props.dateFormat || utils.extractDateFormat(format.value || "") || constants.DEFAULT_FORMATS_DATE;
+    });
+    const isValidValue = (date) => {
+      return utils$1.isValidRange(date) && (disabledDate ? !disabledDate(date[0].toDate()) && !disabledDate(date[1].toDate()) : true);
+    };
+    const leftPrevYear = () => {
+      leftDate.value = adjustDateByView(leftCurrentView.value, leftDate.value, false);
+      if (!props.unlinkPanels) {
+        rightDate.value = leftDate.value.add(1, "month");
+      }
+      handlePanelChange("year");
+    };
+    const leftPrevMonth = () => {
+      leftDate.value = leftDate.value.subtract(1, "month");
+      if (!props.unlinkPanels) {
+        rightDate.value = leftDate.value.add(1, "month");
+      }
+      handlePanelChange("month");
+    };
+    const rightNextYear = () => {
+      if (!props.unlinkPanels) {
+        leftDate.value = adjustDateByView(rightCurrentView.value, leftDate.value, true);
+        rightDate.value = leftDate.value.add(1, "month");
+      } else {
+        rightDate.value = adjustDateByView(rightCurrentView.value, rightDate.value, true);
+      }
+      handlePanelChange("year");
+    };
+    const rightNextMonth = () => {
+      if (!props.unlinkPanels) {
+        leftDate.value = leftDate.value.add(1, "month");
+        rightDate.value = leftDate.value.add(1, "month");
+      } else {
+        rightDate.value = rightDate.value.add(1, "month");
+      }
+      handlePanelChange("month");
+    };
+    const leftNextYear = () => {
+      leftDate.value = adjustDateByView(leftCurrentView.value, leftDate.value, true);
+      handlePanelChange("year");
+    };
+    const leftNextMonth = () => {
+      leftDate.value = leftDate.value.add(1, "month");
+      handlePanelChange("month");
+    };
+    const rightPrevYear = () => {
+      rightDate.value = adjustDateByView(rightCurrentView.value, rightDate.value, false);
+      handlePanelChange("year");
+    };
+    const rightPrevMonth = () => {
+      rightDate.value = rightDate.value.subtract(1, "month");
+      handlePanelChange("month");
+    };
+    const enableMonthArrow = vue.computed(() => {
+      const nextMonth = (leftMonth.value + 1) % 12;
+      const yearOffset = leftMonth.value + 1 >= 12 ? 1 : 0;
+      return props.unlinkPanels && new Date(leftYear.value + yearOffset, nextMonth) < new Date(rightYear.value, rightMonth.value);
+    });
+    const enableYearArrow = vue.computed(() => {
+      return props.unlinkPanels && rightYear.value * 12 + rightMonth.value - (leftYear.value * 12 + leftMonth.value + 1) >= 12;
+    });
+    const btnDisabled = vue.computed(() => {
+      return !(minDate.value && maxDate.value && !rangeState.value.selecting && utils$1.isValidRange([minDate.value, maxDate.value]));
+    });
+    const showTime = vue.computed(() => props.type === "datetime" || props.type === "datetimerange");
+    const formatEmit = (emitDayjs, index) => {
+      if (!emitDayjs)
+        return;
+      if (defaultTime) {
+        const defaultTimeD = dayjs__default["default"](defaultTime[index] || defaultTime).locale(lang.value);
+        return defaultTimeD.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
+      }
+      return emitDayjs;
+    };
+    const handleRangePick = (val, close = true) => {
+      const min_ = val.minDate;
+      const max_ = val.maxDate;
+      const minDate_ = formatEmit(min_, 0);
+      const maxDate_ = formatEmit(max_, 1);
+      if (maxDate.value === maxDate_ && minDate.value === minDate_) {
+        return;
+      }
+      emit("calendar-change", [min_.toDate(), max_ && max_.toDate()]);
+      maxDate.value = maxDate_;
+      minDate.value = minDate_;
+      if (!showTime.value && close) {
+        close = !minDate_ || !maxDate_;
+      }
+      handleRangeConfirm(close);
+    };
+    const minTimePickerVisible = vue.ref(false);
+    const maxTimePickerVisible = vue.ref(false);
+    const handleMinTimeClose = () => {
+      minTimePickerVisible.value = false;
+    };
+    const handleMaxTimeClose = () => {
+      maxTimePickerVisible.value = false;
+    };
+    const handleDateInput = (value, type) => {
+      dateUserInput.value[type] = value;
+      const parsedValueD = dayjs__default["default"](value, dateFormat.value).locale(lang.value);
+      if (parsedValueD.isValid()) {
+        if (disabledDate && disabledDate(parsedValueD.toDate())) {
+          return;
+        }
+        if (type === "min") {
+          leftDate.value = parsedValueD;
+          minDate.value = (minDate.value || leftDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
+          if (!props.unlinkPanels && (!maxDate.value || maxDate.value.isBefore(minDate.value))) {
+            rightDate.value = parsedValueD.add(1, "month");
+            maxDate.value = minDate.value.add(1, "month");
+          }
+        } else {
+          rightDate.value = parsedValueD;
+          maxDate.value = (maxDate.value || rightDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
+          if (!props.unlinkPanels && (!minDate.value || minDate.value.isAfter(maxDate.value))) {
+            leftDate.value = parsedValueD.subtract(1, "month");
+            minDate.value = maxDate.value.subtract(1, "month");
+          }
+        }
+        sortDates(minDate.value, maxDate.value);
+        handleRangeConfirm(true);
+      }
+    };
+    const handleDateChange = (_, type) => {
+      dateUserInput.value[type] = null;
+    };
+    const handleTimeInput = (value, type) => {
+      timeUserInput.value[type] = value;
+      const parsedValueD = dayjs__default["default"](value, timeFormat.value).locale(lang.value);
+      if (parsedValueD.isValid()) {
+        if (type === "min") {
+          minTimePickerVisible.value = true;
+          minDate.value = (minDate.value || leftDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
+        } else {
+          maxTimePickerVisible.value = true;
+          maxDate.value = (maxDate.value || rightDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
+          rightDate.value = maxDate.value;
+        }
+      }
+    };
+    const handleTimeChange = (_value, type) => {
+      timeUserInput.value[type] = null;
+      if (type === "min") {
+        leftDate.value = minDate.value;
+        minTimePickerVisible.value = false;
+        if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
+          maxDate.value = minDate.value;
+        }
+      } else {
+        rightDate.value = maxDate.value;
+        maxTimePickerVisible.value = false;
+        if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
+          minDate.value = maxDate.value;
+        }
+      }
+      handleRangeConfirm(true);
+    };
+    const handleMinTimePick = (value, visible, first) => {
+      if (timeUserInput.value.min)
+        return;
+      if (value) {
+        leftDate.value = value;
+        minDate.value = (minDate.value || leftDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
+      }
+      if (!first) {
+        minTimePickerVisible.value = visible;
+      }
+      if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
+        maxDate.value = minDate.value;
+        rightDate.value = value;
+        vue.nextTick(() => {
+          parseValue(props.parsedValue);
+        });
+      }
+      handleRangeConfirm(true);
+    };
+    const handleMaxTimePick = (value, visible, first) => {
+      if (timeUserInput.value.max)
+        return;
+      if (value) {
+        rightDate.value = value;
+        maxDate.value = (maxDate.value || rightDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
+      }
+      if (!first) {
+        maxTimePickerVisible.value = visible;
+      }
+      if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
+        minDate.value = maxDate.value;
+      }
+      handleRangeConfirm(true);
+    };
+    const handleClear = () => {
+      let valueOnClear = null;
+      if (pickerBase == null ? void 0 : pickerBase.emptyValues) {
+        valueOnClear = pickerBase.emptyValues.valueOnClear.value;
+      }
+      leftDate.value = utils$1.getDefaultValue(vue.unref(defaultValue), {
+        lang: vue.unref(lang),
+        unit: "month",
+        unlinkPanels: props.unlinkPanels
+      })[0];
+      rightDate.value = leftDate.value.add(1, "month");
+      maxDate.value = void 0;
+      minDate.value = void 0;
+      handleRangeConfirm(true);
+      emit("pick", valueOnClear);
+    };
+    const formatToString = (value) => {
+      return shared.isArray(value) ? value.map((_) => _.format(format.value)) : value.format(format.value);
+    };
+    const parseUserInput = (value) => {
+      return utils$1.correctlyParseUserInput(value, format.value || "", lang.value, isDefaultFormat);
+    };
+    function sortDates(minDate2, maxDate2) {
+      if (props.unlinkPanels && maxDate2) {
+        const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
+        const minDateMonth = (minDate2 == null ? void 0 : minDate2.month()) || 0;
+        const maxDateYear = maxDate2.year();
+        const maxDateMonth = maxDate2.month();
+        rightDate.value = minDateYear === maxDateYear && minDateMonth === maxDateMonth ? maxDate2.add(1, unit) : maxDate2;
+      } else {
+        rightDate.value = leftDate.value.add(1, unit);
+        if (maxDate2) {
+          rightDate.value = rightDate.value.hour(maxDate2.hour()).minute(maxDate2.minute()).second(maxDate2.second());
+        }
+      }
+    }
+    emit("set-picker-option", ["isValidValue", isValidValue]);
+    emit("set-picker-option", ["parseUserInput", parseUserInput]);
+    emit("set-picker-option", ["formatToString", formatToString]);
+    emit("set-picker-option", ["handleClear", handleClear]);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([
+          vue.unref(ppNs).b(),
+          vue.unref(drpNs).b(),
+          vue.unref(ppNs).is("border", _ctx.border),
+          vue.unref(ppNs).is("disabled", _ctx.disabled),
+          {
+            "has-sidebar": _ctx.$slots.sidebar || vue.unref(hasShortcuts),
+            "has-time": vue.unref(showTime)
+          }
+        ])
+      }, [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
+        }, [
+          vue.renderSlot(_ctx.$slots, "sidebar", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }),
+          vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
+              return vue.openBlock(), vue.createElementBlock("button", {
+                key,
+                type: "button",
+                disabled: _ctx.disabled,
+                class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
+                onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
+              }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
+            }), 128))
+          ], 2)) : vue.createCommentVNode("v-if", true),
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("body"))
+          }, [
+            vue.unref(showTime) ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              class: vue.normalizeClass(vue.unref(drpNs).e("time-header"))
+            }, [
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass(vue.unref(drpNs).e("editors-wrap"))
+              }, [
+                vue.createElementVNode("span", {
+                  class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
+                }, [
+                  vue.createVNode(vue.unref(index$1.ElInput), {
+                    size: "small",
+                    disabled: vue.unref(rangeState).selecting || _ctx.disabled,
+                    placeholder: vue.unref(t)("el.datepicker.startDate"),
+                    class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
+                    "model-value": vue.unref(minVisibleDate),
+                    "validate-event": false,
+                    onInput: (val) => handleDateInput(val, "min"),
+                    onChange: (val) => handleDateChange(val, "min")
+                  }, null, 8, ["disabled", "placeholder", "class", "model-value", "onInput", "onChange"])
+                ], 2),
+                vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
+                  class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
+                }, [
+                  vue.createVNode(vue.unref(index$1.ElInput), {
+                    size: "small",
+                    class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
+                    disabled: vue.unref(rangeState).selecting || _ctx.disabled,
+                    placeholder: vue.unref(t)("el.datepicker.startTime"),
+                    "model-value": vue.unref(minVisibleTime),
+                    "validate-event": false,
+                    onFocus: ($event) => minTimePickerVisible.value = true,
+                    onInput: (val) => handleTimeInput(val, "min"),
+                    onChange: (val) => handleTimeChange(val, "min")
+                  }, null, 8, ["class", "disabled", "placeholder", "model-value", "onFocus", "onInput", "onChange"]),
+                  vue.createVNode(vue.unref(panelTimePick["default"]), {
+                    visible: minTimePickerVisible.value,
+                    format: vue.unref(timeFormat),
+                    "datetime-role": "start",
+                    "parsed-value": leftDate.value,
+                    onPick: handleMinTimePick
+                  }, null, 8, ["visible", "format", "parsed-value"])
+                ], 2)), [
+                  [vue.unref(index$2["default"]), handleMinTimeClose]
+                ])
+              ], 2),
+              vue.createElementVNode("span", null, [
+                vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                  default: vue.withCtx(() => [
+                    vue.createVNode(vue.unref(iconsVue.ArrowRight))
+                  ]),
+                  _: 1
+                })
+              ]),
+              vue.createElementVNode("span", {
+                class: vue.normalizeClass([vue.unref(drpNs).e("editors-wrap"), "is-right"])
+              }, [
+                vue.createElementVNode("span", {
+                  class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
+                }, [
+                  vue.createVNode(vue.unref(index$1.ElInput), {
+                    size: "small",
+                    class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
+                    disabled: vue.unref(rangeState).selecting || _ctx.disabled,
+                    placeholder: vue.unref(t)("el.datepicker.endDate"),
+                    "model-value": vue.unref(maxVisibleDate),
+                    readonly: !vue.unref(minDate),
+                    "validate-event": false,
+                    onInput: (val) => handleDateInput(val, "max"),
+                    onChange: (val) => handleDateChange(val, "max")
+                  }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly", "onInput", "onChange"])
+                ], 2),
+                vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
+                  class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
+                }, [
+                  vue.createVNode(vue.unref(index$1.ElInput), {
+                    size: "small",
+                    class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
+                    disabled: vue.unref(rangeState).selecting || _ctx.disabled,
+                    placeholder: vue.unref(t)("el.datepicker.endTime"),
+                    "model-value": vue.unref(maxVisibleTime),
+                    readonly: !vue.unref(minDate),
+                    "validate-event": false,
+                    onFocus: ($event) => vue.unref(minDate) && (maxTimePickerVisible.value = true),
+                    onInput: (val) => handleTimeInput(val, "max"),
+                    onChange: (val) => handleTimeChange(val, "max")
+                  }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly", "onFocus", "onInput", "onChange"]),
+                  vue.createVNode(vue.unref(panelTimePick["default"]), {
+                    "datetime-role": "end",
+                    visible: maxTimePickerVisible.value,
+                    format: vue.unref(timeFormat),
+                    "parsed-value": rightDate.value,
+                    onPick: handleMaxTimePick
+                  }, null, 8, ["visible", "format", "parsed-value"])
+                ], 2)), [
+                  [vue.unref(index$2["default"]), handleMaxTimeClose]
+                ])
+              ], 2)
+            ], 2)) : vue.createCommentVNode("v-if", true),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-left"])
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(drpNs).e("header"))
+              }, [
+                vue.createElementVNode("button", {
+                  type: "button",
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
+                  "aria-label": vue.unref(t)(`el.datepicker.prevYear`),
+                  disabled: _ctx.disabled,
+                  onClick: leftPrevYear
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["aria-label", "disabled"]),
+                vue.withDirectives(vue.createElementVNode("button", {
+                  type: "button",
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
+                  "aria-label": vue.unref(t)(`el.datepicker.prevMonth`),
+                  disabled: _ctx.disabled,
+                  onClick: leftPrevMonth
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-month", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.ArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["aria-label", "disabled"]), [
+                  [vue.vShow, vue.unref(leftCurrentView) === "date"]
+                ]),
+                _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 0,
+                  type: "button",
+                  disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
+                  class: vue.normalizeClass([[
+                    vue.unref(ppNs).e("icon-btn"),
+                    vue.unref(ppNs).is("disabled", !vue.unref(enableYearArrow) || _ctx.disabled)
+                  ], "d-arrow-right"]),
+                  "aria-label": vue.unref(t)(`el.datepicker.nextYear`),
+                  onClick: leftNextYear
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
+                _ctx.unlinkPanels && vue.unref(leftCurrentView) === "date" ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 1,
+                  type: "button",
+                  disabled: !vue.unref(enableMonthArrow) || _ctx.disabled,
+                  class: vue.normalizeClass([[
+                    vue.unref(ppNs).e("icon-btn"),
+                    vue.unref(ppNs).is("disabled", !vue.unref(enableMonthArrow) || _ctx.disabled)
+                  ], "arrow-right"]),
+                  "aria-label": vue.unref(t)(`el.datepicker.nextMonth`),
+                  onClick: leftNextMonth
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-month", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.ArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
+                vue.createElementVNode("div", null, [
+                  vue.createElementVNode("span", {
+                    role: "button",
+                    class: vue.normalizeClass(vue.unref(drpNs).e("header-label")),
+                    "aria-live": "polite",
+                    tabindex: "0",
+                    onKeydown: vue.withKeys(($event) => vue.unref(showLeftPicker)("year"), ["enter"]),
+                    onClick: ($event) => vue.unref(showLeftPicker)("year")
+                  }, vue.toDisplayString(vue.unref(leftYearLabel)), 43, ["onKeydown", "onClick"]),
+                  vue.withDirectives(vue.createElementVNode("span", {
+                    role: "button",
+                    "aria-live": "polite",
+                    tabindex: "0",
+                    class: vue.normalizeClass([
+                      vue.unref(drpNs).e("header-label"),
+                      { active: vue.unref(leftCurrentView) === "month" }
+                    ]),
+                    onKeydown: vue.withKeys(($event) => vue.unref(showLeftPicker)("month"), ["enter"]),
+                    onClick: ($event) => vue.unref(showLeftPicker)("month")
+                  }, vue.toDisplayString(vue.unref(t)(`el.datepicker.month${leftDate.value.month() + 1}`)), 43, ["onKeydown", "onClick"]), [
+                    [vue.vShow, vue.unref(leftCurrentView) === "date"]
+                  ])
+                ])
+              ], 2),
+              vue.unref(leftCurrentView) === "date" ? (vue.openBlock(), vue.createBlock(basicDateTable["default"], {
+                key: 0,
+                ref_key: "leftCurrentViewRef",
+                ref: leftCurrentViewRef,
+                "selection-mode": "range",
+                date: leftDate.value,
+                "min-date": vue.unref(minDate),
+                "max-date": vue.unref(maxDate),
+                "range-state": vue.unref(rangeState),
+                "disabled-date": vue.unref(disabledDate),
+                "cell-class-name": vue.unref(cellClassName),
+                "show-week-number": _ctx.showWeekNumber,
+                disabled: _ctx.disabled,
+                onChangerange: vue.unref(handleChangeRange),
+                onPick: handleRangePick,
+                onSelect: vue.unref(onSelect)
+              }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "show-week-number", "disabled", "onChangerange", "onSelect"])) : vue.createCommentVNode("v-if", true),
+              vue.unref(leftCurrentView) === "year" ? (vue.openBlock(), vue.createBlock(basicYearTable["default"], {
+                key: 1,
+                ref_key: "leftCurrentViewRef",
+                ref: leftCurrentViewRef,
+                "selection-mode": "year",
+                date: leftDate.value,
+                "disabled-date": vue.unref(disabledDate),
+                "parsed-value": _ctx.parsedValue,
+                disabled: _ctx.disabled,
+                onPick: vue.unref(handleLeftYearPick)
+              }, null, 8, ["date", "disabled-date", "parsed-value", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true),
+              vue.unref(leftCurrentView) === "month" ? (vue.openBlock(), vue.createBlock(basicMonthTable["default"], {
+                key: 2,
+                ref_key: "leftCurrentViewRef",
+                ref: leftCurrentViewRef,
+                "selection-mode": "month",
+                date: leftDate.value,
+                "parsed-value": _ctx.parsedValue,
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                onPick: vue.unref(handleLeftMonthPick)
+              }, null, 8, ["date", "parsed-value", "disabled-date", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true)
+            ], 2),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-right"])
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass([
+                  vue.unref(drpNs).e("header"),
+                  vue.unref(ppNs).is("disabled", !vue.unref(enableYearArrow) || _ctx.disabled)
+                ])
+              }, [
+                _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 0,
+                  type: "button",
+                  disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
+                  "aria-label": vue.unref(t)(`el.datepicker.prevYear`),
+                  onClick: rightPrevYear
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
+                _ctx.unlinkPanels && vue.unref(rightCurrentView) === "date" ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 1,
+                  type: "button",
+                  disabled: !vue.unref(enableMonthArrow) || _ctx.disabled,
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
+                  "aria-label": vue.unref(t)(`el.datepicker.prevMonth`),
+                  onClick: rightPrevMonth
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-month", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.ArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "aria-label"])) : vue.createCommentVNode("v-if", true),
+                vue.createElementVNode("button", {
+                  type: "button",
+                  "aria-label": vue.unref(t)(`el.datepicker.nextYear`),
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
+                  disabled: _ctx.disabled,
+                  onClick: rightNextYear
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["aria-label", "disabled"]),
+                vue.withDirectives(vue.createElementVNode("button", {
+                  type: "button",
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-right"]),
+                  disabled: _ctx.disabled,
+                  "aria-label": vue.unref(t)(`el.datepicker.nextMonth`),
+                  onClick: rightNextMonth
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-month", {}, () => [
+                    vue.createVNode(vue.unref(index$3.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.ArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "aria-label"]), [
+                  [vue.vShow, vue.unref(rightCurrentView) === "date"]
+                ]),
+                vue.createElementVNode("div", null, [
+                  vue.createElementVNode("span", {
+                    role: "button",
+                    class: vue.normalizeClass(vue.unref(drpNs).e("header-label")),
+                    "aria-live": "polite",
+                    tabindex: "0",
+                    onKeydown: vue.withKeys(($event) => vue.unref(showRightPicker)("year"), ["enter"]),
+                    onClick: ($event) => vue.unref(showRightPicker)("year")
+                  }, vue.toDisplayString(vue.unref(rightYearLabel)), 43, ["onKeydown", "onClick"]),
+                  vue.withDirectives(vue.createElementVNode("span", {
+                    role: "button",
+                    "aria-live": "polite",
+                    tabindex: "0",
+                    class: vue.normalizeClass([
+                      vue.unref(drpNs).e("header-label"),
+                      { active: vue.unref(rightCurrentView) === "month" }
+                    ]),
+                    onKeydown: vue.withKeys(($event) => vue.unref(showRightPicker)("month"), ["enter"]),
+                    onClick: ($event) => vue.unref(showRightPicker)("month")
+                  }, vue.toDisplayString(vue.unref(t)(`el.datepicker.month${rightDate.value.month() + 1}`)), 43, ["onKeydown", "onClick"]), [
+                    [vue.vShow, vue.unref(rightCurrentView) === "date"]
+                  ])
+                ])
+              ], 2),
+              vue.unref(rightCurrentView) === "date" ? (vue.openBlock(), vue.createBlock(basicDateTable["default"], {
+                key: 0,
+                ref_key: "rightCurrentViewRef",
+                ref: rightCurrentViewRef,
+                "selection-mode": "range",
+                date: rightDate.value,
+                "min-date": vue.unref(minDate),
+                "max-date": vue.unref(maxDate),
+                "range-state": vue.unref(rangeState),
+                "disabled-date": vue.unref(disabledDate),
+                "cell-class-name": vue.unref(cellClassName),
+                "show-week-number": _ctx.showWeekNumber,
+                disabled: _ctx.disabled,
+                onChangerange: vue.unref(handleChangeRange),
+                onPick: handleRangePick,
+                onSelect: vue.unref(onSelect)
+              }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "show-week-number", "disabled", "onChangerange", "onSelect"])) : vue.createCommentVNode("v-if", true),
+              vue.unref(rightCurrentView) === "year" ? (vue.openBlock(), vue.createBlock(basicYearTable["default"], {
+                key: 1,
+                ref_key: "rightCurrentViewRef",
+                ref: rightCurrentViewRef,
+                "selection-mode": "year",
+                date: rightDate.value,
+                "disabled-date": vue.unref(disabledDate),
+                "parsed-value": _ctx.parsedValue,
+                disabled: _ctx.disabled,
+                onPick: vue.unref(handleRightYearPick)
+              }, null, 8, ["date", "disabled-date", "parsed-value", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true),
+              vue.unref(rightCurrentView) === "month" ? (vue.openBlock(), vue.createBlock(basicMonthTable["default"], {
+                key: 2,
+                ref_key: "rightCurrentViewRef",
+                ref: rightCurrentViewRef,
+                "selection-mode": "month",
+                date: rightDate.value,
+                "parsed-value": _ctx.parsedValue,
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                onPick: vue.unref(handleRightMonthPick)
+              }, null, 8, ["date", "parsed-value", "disabled-date", "disabled", "onPick"])) : vue.createCommentVNode("v-if", true)
+            ], 2)
+          ], 2)
+        ], 2),
+        _ctx.showFooter && vue.unref(showTime) && (_ctx.showConfirm || vue.unref(clearable)) ? (vue.openBlock(), vue.createElementBlock("div", {
+          key: 0,
+          class: vue.normalizeClass(vue.unref(ppNs).e("footer"))
+        }, [
+          vue.unref(clearable) ? (vue.openBlock(), vue.createBlock(vue.unref(index$4.ElButton), {
+            key: 0,
+            text: "",
+            size: "small",
+            class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
+            onClick: handleClear
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.clear")), 1)
+            ]),
+            _: 1
+          }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
+          _ctx.showConfirm ? (vue.openBlock(), vue.createBlock(vue.unref(index$4.ElButton), {
+            key: 1,
+            plain: "",
+            size: "small",
+            class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
+            disabled: vue.unref(btnDisabled),
+            onClick: ($event) => vue.unref(handleRangeConfirm)(false)
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 1)
+            ]),
+            _: 1
+          }, 8, ["class", "disabled", "onClick"])) : vue.createCommentVNode("v-if", true)
+        ], 2)) : vue.createCommentVNode("v-if", true)
+      ], 2);
+    };
+  }
+});
+var DateRangePickPanel = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "panel-date-range.vue"]]);
+
+exports["default"] = DateRangePickPanel;
+//# sourceMappingURL=panel-date-range.js.map

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

@@ -0,0 +1,87 @@
+import dayjs from 'dayjs';
+declare function __VLS_template(): {
+    sidebar?(_: {
+        class: string;
+    }): any;
+    "prev-year"?(_: {}): any;
+    "prev-year"?(_: {}): any;
+    "prev-month"?(_: {}): any;
+    "prev-month"?(_: {}): any;
+    "next-year"?(_: {}): any;
+    "next-year"?(_: {}): any;
+    "next-month"?(_: {}): any;
+    "next-month"?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "calendar-change": (...args: any[]) => void;
+    "panel-change": (...args: any[]) => void;
+    pick: (...args: any[]) => void;
+    "set-picker-option": (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+}>> & {
+    onPick?: ((...args: any[]) => any) | undefined;
+    "onCalendar-change"?: ((...args: any[]) => any) | undefined;
+    "onPanel-change"?: ((...args: any[]) => any) | undefined;
+    "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly border: boolean;
+    readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showWeekNumber: boolean;
+    readonly unlinkPanels: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,278 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var index$1 = require('../../../icon/index.js');
+var iconsVue = require('@element-plus/icons-vue');
+var utils = require('../utils.js');
+var panelMonthRange = require('../props/panel-month-range.js');
+var useMonthRangeHeader = require('../composables/use-month-range-header.js');
+var useRangePicker = require('../composables/use-range-picker.js');
+var constants$1 = require('../constants.js');
+var basicMonthTable = require('./basic-month-table.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+var index = require('../../../../hooks/use-locale/index.js');
+var constants = require('../../../time-picker/src/constants.js');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const unit = "year";
+const __default__ = vue.defineComponent({
+  name: "DatePickerMonthRange"
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: panelMonthRange.panelMonthRangeProps,
+  emits: panelMonthRange.panelMonthRangeEmits,
+  setup(__props, { emit }) {
+    const props = __props;
+    const { lang } = index.useLocale();
+    const pickerBase = vue.inject(constants.PICKER_BASE_INJECTION_KEY);
+    const isDefaultFormat = vue.inject(constants$1.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
+    const { shortcuts, disabledDate, cellClassName } = pickerBase.props;
+    const format = vue.toRef(pickerBase.props, "format");
+    const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
+    const leftDate = vue.ref(dayjs__default["default"]().locale(lang.value));
+    const rightDate = vue.ref(dayjs__default["default"]().locale(lang.value).add(1, unit));
+    const {
+      minDate,
+      maxDate,
+      rangeState,
+      ppNs,
+      drpNs,
+      handleChangeRange,
+      handleRangeConfirm,
+      handleShortcutClick,
+      onSelect,
+      parseValue
+    } = useRangePicker.useRangePicker(props, {
+      defaultValue,
+      leftDate,
+      rightDate,
+      unit,
+      sortDates
+    });
+    const hasShortcuts = vue.computed(() => !!shortcuts.length);
+    const {
+      leftPrevYear,
+      rightNextYear,
+      leftNextYear,
+      rightPrevYear,
+      leftLabel,
+      rightLabel,
+      leftYear,
+      rightYear
+    } = useMonthRangeHeader.useMonthRangeHeader({
+      unlinkPanels: vue.toRef(props, "unlinkPanels"),
+      leftDate,
+      rightDate
+    });
+    const enableYearArrow = vue.computed(() => {
+      return props.unlinkPanels && rightYear.value > leftYear.value + 1;
+    });
+    const handleRangePick = (val, close = true) => {
+      const minDate_ = val.minDate;
+      const maxDate_ = val.maxDate;
+      if (maxDate.value === maxDate_ && minDate.value === minDate_) {
+        return;
+      }
+      emit("calendar-change", [minDate_.toDate(), maxDate_ && maxDate_.toDate()]);
+      maxDate.value = maxDate_;
+      minDate.value = minDate_;
+      if (!close)
+        return;
+      handleRangeConfirm();
+    };
+    const handleClear = () => {
+      leftDate.value = utils.getDefaultValue(vue.unref(defaultValue), {
+        lang: vue.unref(lang),
+        unit: "year",
+        unlinkPanels: props.unlinkPanels
+      })[0];
+      rightDate.value = leftDate.value.add(1, "year");
+      emit("pick", null);
+    };
+    const formatToString = (value) => {
+      return shared.isArray(value) ? value.map((_) => _.format(format.value)) : value.format(format.value);
+    };
+    const parseUserInput = (value) => {
+      return utils.correctlyParseUserInput(value, format.value, lang.value, isDefaultFormat);
+    };
+    function sortDates(minDate2, maxDate2) {
+      if (props.unlinkPanels && maxDate2) {
+        const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
+        const maxDateYear = maxDate2.year();
+        rightDate.value = minDateYear === maxDateYear ? maxDate2.add(1, unit) : maxDate2;
+      } else {
+        rightDate.value = leftDate.value.add(1, unit);
+      }
+    }
+    vue.watch(() => props.visible, (visible) => {
+      if (!visible && rangeState.value.selecting) {
+        parseValue(props.parsedValue);
+        onSelect(false);
+      }
+    });
+    emit("set-picker-option", ["isValidValue", utils.isValidRange]);
+    emit("set-picker-option", ["formatToString", formatToString]);
+    emit("set-picker-option", ["parseUserInput", parseUserInput]);
+    emit("set-picker-option", ["handleClear", handleClear]);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([
+          vue.unref(ppNs).b(),
+          vue.unref(drpNs).b(),
+          vue.unref(ppNs).is("border", _ctx.border),
+          vue.unref(ppNs).is("disabled", _ctx.disabled),
+          {
+            "has-sidebar": Boolean(_ctx.$slots.sidebar) || vue.unref(hasShortcuts)
+          }
+        ])
+      }, [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
+        }, [
+          vue.renderSlot(_ctx.$slots, "sidebar", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }),
+          vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
+              return vue.openBlock(), vue.createElementBlock("button", {
+                key,
+                type: "button",
+                class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
+                disabled: _ctx.disabled,
+                onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
+              }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
+            }), 128))
+          ], 2)) : vue.createCommentVNode("v-if", true),
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("body"))
+          }, [
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-left"])
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(drpNs).e("header"))
+              }, [
+                vue.createElementVNode("button", {
+                  type: "button",
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
+                  disabled: _ctx.disabled,
+                  onClick: vue.unref(leftPrevYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"]),
+                _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 0,
+                  type: "button",
+                  disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
+                  class: vue.normalizeClass([[
+                    vue.unref(ppNs).e("icon-btn"),
+                    { [vue.unref(ppNs).is("disabled")]: !vue.unref(enableYearArrow) }
+                  ], "d-arrow-right"]),
+                  onClick: vue.unref(leftNextYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
+                vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(leftLabel)), 1)
+              ], 2),
+              vue.createVNode(basicMonthTable["default"], {
+                "selection-mode": "range",
+                date: leftDate.value,
+                "min-date": vue.unref(minDate),
+                "max-date": vue.unref(maxDate),
+                "range-state": vue.unref(rangeState),
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                "cell-class-name": vue.unref(cellClassName),
+                onChangerange: vue.unref(handleChangeRange),
+                onPick: handleRangePick,
+                onSelect: vue.unref(onSelect)
+              }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
+            ], 2),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-right"])
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(drpNs).e("header"))
+              }, [
+                _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 0,
+                  type: "button",
+                  disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
+                  class: vue.normalizeClass([[vue.unref(ppNs).e("icon-btn"), { "is-disabled": !vue.unref(enableYearArrow) }], "d-arrow-left"]),
+                  onClick: vue.unref(rightPrevYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
+                vue.createElementVNode("button", {
+                  type: "button",
+                  class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
+                  disabled: _ctx.disabled,
+                  onClick: vue.unref(rightNextYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"]),
+                vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(rightLabel)), 1)
+              ], 2),
+              vue.createVNode(basicMonthTable["default"], {
+                "selection-mode": "range",
+                date: rightDate.value,
+                "min-date": vue.unref(minDate),
+                "max-date": vue.unref(maxDate),
+                "range-state": vue.unref(rangeState),
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                "cell-class-name": vue.unref(cellClassName),
+                onChangerange: vue.unref(handleChangeRange),
+                onPick: handleRangePick,
+                onSelect: vue.unref(onSelect)
+              }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
+            ], 2)
+          ], 2)
+        ], 2)
+      ], 2);
+    };
+  }
+});
+var MonthRangePickPanel = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "panel-month-range.vue"]]);
+
+exports["default"] = MonthRangePickPanel;
+//# sourceMappingURL=panel-month-range.js.map

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

@@ -0,0 +1,53 @@
+import dayjs from 'dayjs';
+declare function __VLS_template(): {
+    sidebar?(_: {
+        class: string;
+    }): any;
+    "prev-year"?(_: {}): any;
+    "prev-year"?(_: {}): any;
+    "next-year"?(_: {}): any;
+    "next-year"?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {
+    readonly disabled: boolean;
+    readonly border: boolean;
+    readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly unlinkPanels: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -0,0 +1,305 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var iconsVue = require('@element-plus/icons-vue');
+var index$1 = require('../../../icon/index.js');
+var panelYearRange = require('../props/panel-year-range.js');
+var useYearRangeHeader = require('../composables/use-year-range-header.js');
+var useRangePicker = require('../composables/use-range-picker.js');
+var utils = require('../utils.js');
+var constants = require('../constants.js');
+var basicYearTable = require('./basic-year-table.js');
+var pluginVue_exportHelper = require('../../../../_virtual/plugin-vue_export-helper.js');
+var index = require('../../../../hooks/use-locale/index.js');
+var constants$1 = require('../../../time-picker/src/constants.js');
+var shared = require('@vue/shared');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const step = 10;
+const unit = "year";
+const __default__ = vue.defineComponent({
+  name: "DatePickerYearRange"
+});
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  ...__default__,
+  props: panelYearRange.panelYearRangeProps,
+  emits: panelYearRange.panelYearRangeEmits,
+  setup(__props, { emit }) {
+    const props = __props;
+    const { lang } = index.useLocale();
+    const leftDate = vue.ref(dayjs__default["default"]().locale(lang.value));
+    const rightDate = vue.ref(dayjs__default["default"]().locale(lang.value).add(step, unit));
+    const isDefaultFormat = vue.inject(constants.ROOT_PICKER_IS_DEFAULT_FORMAT_INJECTION_KEY, void 0);
+    const pickerBase = vue.inject(constants$1.PICKER_BASE_INJECTION_KEY);
+    const { shortcuts, disabledDate, cellClassName } = pickerBase.props;
+    const format = vue.toRef(pickerBase.props, "format");
+    const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
+    const {
+      minDate,
+      maxDate,
+      rangeState,
+      ppNs,
+      drpNs,
+      handleChangeRange,
+      handleRangeConfirm,
+      handleShortcutClick,
+      onSelect,
+      parseValue
+    } = useRangePicker.useRangePicker(props, {
+      defaultValue,
+      leftDate,
+      rightDate,
+      step,
+      unit,
+      sortDates
+    });
+    const {
+      leftPrevYear,
+      rightNextYear,
+      leftNextYear,
+      rightPrevYear,
+      leftLabel,
+      rightLabel,
+      leftYear,
+      rightYear
+    } = useYearRangeHeader.useYearRangeHeader({
+      unlinkPanels: vue.toRef(props, "unlinkPanels"),
+      leftDate,
+      rightDate
+    });
+    const hasShortcuts = vue.computed(() => !!shortcuts.length);
+    const panelKls = vue.computed(() => [
+      ppNs.b(),
+      drpNs.b(),
+      ppNs.is("border", props.border),
+      ppNs.is("disabled", props.disabled),
+      {
+        "has-sidebar": Boolean(vue.useSlots().sidebar) || hasShortcuts.value
+      }
+    ]);
+    const leftPanelKls = vue.computed(() => {
+      return {
+        content: [ppNs.e("content"), drpNs.e("content"), "is-left"],
+        arrowLeftBtn: [ppNs.e("icon-btn"), "d-arrow-left"],
+        arrowRightBtn: [
+          ppNs.e("icon-btn"),
+          { [ppNs.is("disabled")]: !enableYearArrow.value },
+          "d-arrow-right"
+        ]
+      };
+    });
+    const rightPanelKls = vue.computed(() => {
+      return {
+        content: [ppNs.e("content"), drpNs.e("content"), "is-right"],
+        arrowLeftBtn: [
+          ppNs.e("icon-btn"),
+          { "is-disabled": !enableYearArrow.value },
+          "d-arrow-left"
+        ],
+        arrowRightBtn: [ppNs.e("icon-btn"), "d-arrow-right"]
+      };
+    });
+    const enableYearArrow = vue.computed(() => {
+      return props.unlinkPanels && rightYear.value > leftYear.value + 1;
+    });
+    const handleRangePick = (val, close = true) => {
+      const minDate_ = val.minDate;
+      const maxDate_ = val.maxDate;
+      if (maxDate.value === maxDate_ && minDate.value === minDate_) {
+        return;
+      }
+      emit("calendar-change", [minDate_.toDate(), maxDate_ && maxDate_.toDate()]);
+      maxDate.value = maxDate_;
+      minDate.value = minDate_;
+      if (!close)
+        return;
+      handleRangeConfirm();
+    };
+    const parseUserInput = (value) => {
+      return utils.correctlyParseUserInput(value, format.value, lang.value, isDefaultFormat);
+    };
+    const formatToString = (value) => {
+      return shared.isArray(value) ? value.map((day) => day.format(format.value)) : value.format(format.value);
+    };
+    const isValidValue = (date) => {
+      return utils.isValidRange(date) && (disabledDate ? !disabledDate(date[0].toDate()) && !disabledDate(date[1].toDate()) : true);
+    };
+    const handleClear = () => {
+      const defaultArr = utils.getDefaultValue(vue.unref(defaultValue), {
+        lang: vue.unref(lang),
+        step,
+        unit,
+        unlinkPanels: props.unlinkPanels
+      });
+      leftDate.value = defaultArr[0];
+      rightDate.value = defaultArr[1];
+      emit("pick", null);
+    };
+    function sortDates(minDate2, maxDate2) {
+      if (props.unlinkPanels && maxDate2) {
+        const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
+        const maxDateYear = maxDate2.year();
+        rightDate.value = minDateYear + step > maxDateYear ? maxDate2.add(step, unit) : maxDate2;
+      } else {
+        rightDate.value = leftDate.value.add(step, unit);
+      }
+    }
+    vue.watch(() => props.visible, (visible) => {
+      if (!visible && rangeState.value.selecting) {
+        parseValue(props.parsedValue);
+        onSelect(false);
+      }
+    });
+    emit("set-picker-option", ["isValidValue", isValidValue]);
+    emit("set-picker-option", ["parseUserInput", parseUserInput]);
+    emit("set-picker-option", ["formatToString", formatToString]);
+    emit("set-picker-option", ["handleClear", handleClear]);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(panelKls))
+      }, [
+        vue.createElementVNode("div", {
+          class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
+        }, [
+          vue.renderSlot(_ctx.$slots, "sidebar", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }),
+          vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
+              return vue.openBlock(), vue.createElementBlock("button", {
+                key,
+                type: "button",
+                class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
+                disabled: _ctx.disabled,
+                onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
+              }, vue.toDisplayString(shortcut.text), 11, ["disabled", "onClick"]);
+            }), 128))
+          ], 2)) : vue.createCommentVNode("v-if", true),
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass(vue.unref(ppNs).e("body"))
+          }, [
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(vue.unref(leftPanelKls).content)
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(drpNs).e("header"))
+              }, [
+                vue.createElementVNode("button", {
+                  type: "button",
+                  class: vue.normalizeClass(vue.unref(leftPanelKls).arrowLeftBtn),
+                  disabled: _ctx.disabled,
+                  onClick: vue.unref(leftPrevYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"]),
+                _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 0,
+                  type: "button",
+                  disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
+                  class: vue.normalizeClass(vue.unref(leftPanelKls).arrowRightBtn),
+                  onClick: vue.unref(leftNextYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
+                vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(leftLabel)), 1)
+              ], 2),
+              vue.createVNode(basicYearTable["default"], {
+                "selection-mode": "range",
+                date: leftDate.value,
+                "min-date": vue.unref(minDate),
+                "max-date": vue.unref(maxDate),
+                "range-state": vue.unref(rangeState),
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                "cell-class-name": vue.unref(cellClassName),
+                onChangerange: vue.unref(handleChangeRange),
+                onPick: handleRangePick,
+                onSelect: vue.unref(onSelect)
+              }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
+            ], 2),
+            vue.createElementVNode("div", {
+              class: vue.normalizeClass(vue.unref(rightPanelKls).content)
+            }, [
+              vue.createElementVNode("div", {
+                class: vue.normalizeClass(vue.unref(drpNs).e("header"))
+              }, [
+                _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
+                  key: 0,
+                  type: "button",
+                  disabled: !vue.unref(enableYearArrow) || _ctx.disabled,
+                  class: vue.normalizeClass(vue.unref(rightPanelKls).arrowLeftBtn),
+                  onClick: vue.unref(rightPrevYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "prev-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowLeft))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"])) : vue.createCommentVNode("v-if", true),
+                vue.createElementVNode("button", {
+                  type: "button",
+                  class: vue.normalizeClass(vue.unref(rightPanelKls).arrowRightBtn),
+                  disabled: _ctx.disabled,
+                  onClick: vue.unref(rightNextYear)
+                }, [
+                  vue.renderSlot(_ctx.$slots, "next-year", {}, () => [
+                    vue.createVNode(vue.unref(index$1.ElIcon), null, {
+                      default: vue.withCtx(() => [
+                        vue.createVNode(vue.unref(iconsVue.DArrowRight))
+                      ]),
+                      _: 1
+                    })
+                  ])
+                ], 10, ["disabled", "onClick"]),
+                vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(rightLabel)), 1)
+              ], 2),
+              vue.createVNode(basicYearTable["default"], {
+                "selection-mode": "range",
+                date: rightDate.value,
+                "min-date": vue.unref(minDate),
+                "max-date": vue.unref(maxDate),
+                "range-state": vue.unref(rangeState),
+                "disabled-date": vue.unref(disabledDate),
+                disabled: _ctx.disabled,
+                "cell-class-name": vue.unref(cellClassName),
+                onChangerange: vue.unref(handleChangeRange),
+                onPick: handleRangePick,
+                onSelect: vue.unref(onSelect)
+              }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "disabled", "cell-class-name", "onChangerange", "onSelect"])
+            ], 2)
+          ], 2)
+        ], 2)
+      ], 2);
+    };
+  }
+});
+var YearRangePickPanel = /* @__PURE__ */ pluginVue_exportHelper["default"](_sfc_main, [["__file", "panel-year-range.vue"]]);
+
+exports["default"] = YearRangePickPanel;
+//# sourceMappingURL=panel-year-range.js.map

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

@@ -0,0 +1,53 @@
+import dayjs from 'dayjs';
+declare function __VLS_template(): {
+    sidebar?(_: {
+        class: string;
+    }): any;
+    "prev-year"?(_: {}): any;
+    "prev-year"?(_: {}): any;
+    "next-year"?(_: {}): any;
+    "next-year"?(_: {}): any;
+};
+declare const __VLS_component: import("vue").DefineComponent<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: (...args: any[]) => void;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays) | ((new (...args: any[]) => dayjs.Dayjs | [dayjs.Dayjs, dayjs.Dayjs]) | (() => import("element-plus/es/components/time-picker").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {
+    readonly disabled: boolean;
+    readonly border: boolean;
+    readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly unlinkPanels: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-panel.d.ts

@@ -0,0 +1,140 @@
+declare const _default: import("vue").DefineComponent<{
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+    readonly arrowControl: BooleanConstructor;
+    readonly unlinkPanels: BooleanConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: BooleanConstructor;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => import("element-plus").DatePickerType) | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => import("element-plus").DatePickerType))[], unknown, unknown, "date", boolean>;
+    readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly disabledHours: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledHours>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledMinutes: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledMinutes>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledSeconds: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledSeconds>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly valueFormat: StringConstructor;
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => import("element-plus/es/components/time-picker").ModelValueType) | ((new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => import("element-plus/es/components/time-picker").ModelValueType))[], unknown, unknown, "", boolean>;
+    readonly defaultValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultTime: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly isRange: BooleanConstructor;
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "calendar-change" | "panel-change" | "visible-change" | "pick")[], "update:modelValue" | "calendar-change" | "panel-change" | "visible-change" | "pick", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+    readonly arrowControl: BooleanConstructor;
+    readonly unlinkPanels: BooleanConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: BooleanConstructor;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => import("element-plus").DatePickerType) | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => import("element-plus").DatePickerType))[], unknown, unknown, "date", boolean>;
+    readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly disabledHours: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledHours>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledMinutes: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledMinutes>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledSeconds: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledSeconds>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly valueFormat: StringConstructor;
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => import("element-plus/es/components/time-picker").ModelValueType) | ((new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => import("element-plus/es/components/time-picker").ModelValueType))[], unknown, unknown, "", boolean>;
+    readonly defaultValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultTime: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => import("element-plus/es/components/time-picker").SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly isRange: BooleanConstructor;
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onPick?: ((...args: any[]) => any) | undefined;
+    "onCalendar-change"?: ((...args: any[]) => any) | undefined;
+    "onPanel-change"?: ((...args: any[]) => any) | undefined;
+    "onVisible-change"?: ((...args: any[]) => any) | undefined;
+}, {
+    readonly disabled: boolean;
+    readonly border: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly type: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => import("element-plus").DatePickerType) | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => import("element-plus").DatePickerType))[], unknown, unknown>;
+    readonly modelValue: import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => import("element-plus/es/components/time-picker").ModelValueType) | ((new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => import("element-plus/es/components/time-picker").ModelValueType))[], unknown, unknown>;
+    readonly clearable: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly shortcuts: unknown[];
+    readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: boolean;
+    readonly showWeekNumber: boolean;
+    readonly arrowControl: boolean;
+    readonly unlinkPanels: boolean;
+    readonly isRange: boolean;
+}>;
+export default _default;

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-panel.js

@@ -0,0 +1,93 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dayjs = require('dayjs');
+var customParseFormat = require('dayjs/plugin/customParseFormat.js');
+var advancedFormat = require('dayjs/plugin/advancedFormat.js');
+var localeData = require('dayjs/plugin/localeData.js');
+var weekOfYear = require('dayjs/plugin/weekOfYear.js');
+var weekYear = require('dayjs/plugin/weekYear.js');
+var dayOfYear = require('dayjs/plugin/dayOfYear.js');
+var isSameOrAfter = require('dayjs/plugin/isSameOrAfter.js');
+var isSameOrBefore = require('dayjs/plugin/isSameOrBefore.js');
+var datePickerPanel = require('./props/date-picker-panel.js');
+var constants$1 = require('./constants.js');
+var panelUtils = require('./panel-utils.js');
+var useCommonPicker = require('../../time-picker/src/composables/use-common-picker.js');
+var constants = require('../../time-picker/src/constants.js');
+var event = require('../../../constants/event.js');
+var index = require('../../../hooks/use-namespace/index.js');
+var types = require('../../../utils/types.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+var customParseFormat__default = /*#__PURE__*/_interopDefaultLegacy(customParseFormat);
+var advancedFormat__default = /*#__PURE__*/_interopDefaultLegacy(advancedFormat);
+var localeData__default = /*#__PURE__*/_interopDefaultLegacy(localeData);
+var weekOfYear__default = /*#__PURE__*/_interopDefaultLegacy(weekOfYear);
+var weekYear__default = /*#__PURE__*/_interopDefaultLegacy(weekYear);
+var dayOfYear__default = /*#__PURE__*/_interopDefaultLegacy(dayOfYear);
+var isSameOrAfter__default = /*#__PURE__*/_interopDefaultLegacy(isSameOrAfter);
+var isSameOrBefore__default = /*#__PURE__*/_interopDefaultLegacy(isSameOrBefore);
+
+function _isSlot(s) {
+  return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
+}
+dayjs__default["default"].extend(localeData__default["default"]);
+dayjs__default["default"].extend(advancedFormat__default["default"]);
+dayjs__default["default"].extend(customParseFormat__default["default"]);
+dayjs__default["default"].extend(weekOfYear__default["default"]);
+dayjs__default["default"].extend(weekYear__default["default"]);
+dayjs__default["default"].extend(dayOfYear__default["default"]);
+dayjs__default["default"].extend(isSameOrAfter__default["default"]);
+dayjs__default["default"].extend(isSameOrBefore__default["default"]);
+var DatePickerPanel = vue.defineComponent({
+  name: "ElDatePickerPanel",
+  install: null,
+  props: datePickerPanel.datePickerPanelProps,
+  emits: [event.UPDATE_MODEL_EVENT, "calendar-change", "panel-change", "visible-change", "pick"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const ns = index.useNamespace("picker-panel");
+    const pickerInjection = vue.inject(constants.PICKER_BASE_INJECTION_KEY, void 0);
+    if (types.isUndefined(pickerInjection)) {
+      const _props = vue.reactive({
+        ...vue.toRefs(props)
+      });
+      vue.provide(constants.PICKER_BASE_INJECTION_KEY, {
+        props: _props
+      });
+    }
+    vue.provide(constants$1.ROOT_PICKER_INJECTION_KEY, {
+      slots,
+      pickerNs: ns
+    });
+    const {
+      parsedValue,
+      onCalendarChange,
+      onPanelChange,
+      onSetPickerOption,
+      onPick
+    } = vue.inject(constants.ROOT_COMMON_PICKER_INJECTION_KEY, () => useCommonPicker.useCommonPicker(props, emit), true);
+    return () => {
+      const Component = panelUtils.getPanel(props.type);
+      return vue.createVNode(Component, vue.mergeProps(props, {
+        "parsedValue": parsedValue.value,
+        "onSet-picker-option": onSetPickerOption,
+        "onCalendar-change": onCalendarChange,
+        "onPanel-change": onPanelChange,
+        "onPick": onPick
+      }), _isSlot(slots) ? slots : {
+        default: () => [slots]
+      });
+    };
+  }
+});
+
+exports["default"] = DatePickerPanel;
+//# sourceMappingURL=date-picker-panel.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/date-picker-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-picker-panel.js","sources":["../../../../../../packages/components/date-picker-panel/src/date-picker-panel.tsx"],"sourcesContent":["import { defineComponent, inject, provide, reactive, toRefs } from 'vue'\nimport dayjs from 'dayjs'\nimport customParseFormat from 'dayjs/plugin/customParseFormat.js'\nimport advancedFormat from 'dayjs/plugin/advancedFormat.js'\nimport localeData from 'dayjs/plugin/localeData.js'\nimport weekOfYear from 'dayjs/plugin/weekOfYear.js'\nimport weekYear from 'dayjs/plugin/weekYear.js'\nimport dayOfYear from 'dayjs/plugin/dayOfYear.js'\nimport isSameOrAfter from 'dayjs/plugin/isSameOrAfter.js'\nimport isSameOrBefore from 'dayjs/plugin/isSameOrBefore.js'\nimport {\n  PICKER_BASE_INJECTION_KEY,\n  ROOT_COMMON_PICKER_INJECTION_KEY,\n} from '@element-plus/components/time-picker'\nimport { useNamespace } from '@element-plus/hooks'\nimport { isUndefined } from '@element-plus/utils'\nimport { UPDATE_MODEL_EVENT } from '@element-plus/constants'\nimport { datePickerPanelProps } from './props/date-picker-panel'\nimport { ROOT_PICKER_INJECTION_KEY } from './constants'\nimport { getPanel } from './panel-utils'\nimport { useCommonPicker } from '../../time-picker/src/composables/use-common-picker'\n\ndayjs.extend(localeData)\ndayjs.extend(advancedFormat)\ndayjs.extend(customParseFormat)\ndayjs.extend(weekOfYear)\ndayjs.extend(weekYear)\ndayjs.extend(dayOfYear)\ndayjs.extend(isSameOrAfter)\ndayjs.extend(isSameOrBefore)\n\nexport default defineComponent({\n  name: 'ElDatePickerPanel',\n  install: null,\n  props: datePickerPanelProps,\n  emits: [\n    UPDATE_MODEL_EVENT,\n    'calendar-change',\n    'panel-change',\n    'visible-change',\n    'pick',\n  ],\n  setup(props, { slots, emit }) {\n    const ns = useNamespace('picker-panel')\n    const pickerInjection = inject(PICKER_BASE_INJECTION_KEY, undefined)\n    if (isUndefined(pickerInjection)) {\n      const _props = reactive({\n        ...toRefs(props),\n      })\n      provide(PICKER_BASE_INJECTION_KEY, {\n        props: _props,\n      })\n    }\n\n    provide(ROOT_PICKER_INJECTION_KEY, {\n      slots,\n      pickerNs: ns,\n    })\n    const {\n      parsedValue,\n      onCalendarChange,\n      onPanelChange,\n      onSetPickerOption,\n      onPick,\n    } = inject(\n      ROOT_COMMON_PICKER_INJECTION_KEY,\n      () => useCommonPicker(props, emit),\n      true\n    )\n\n    return () => {\n      const Component = getPanel(props.type)\n      return (\n        <Component\n          {...props}\n          parsedValue={parsedValue.value}\n          onSet-picker-option={onSetPickerOption}\n          onCalendar-change={onCalendarChange}\n          onPanel-change={onPanelChange}\n          onPick={onPick}\n        >\n          {slots}\n        </Component>\n      )\n    }\n  },\n})\n"],"names":["dayjs","extend","localeData","advancedFormat","customParseFormat","weekOfYear","weekYear","dayOfYear","defineComponent","name","datePickerPanelProps","install","props","slots","useNamespace","emit","isUndefined","reactive","provide","PICKER_BASE_INJECTION_KEY","_props","ROOT_PICKER_INJECTION_KEY","pickerNs","ns","inject","ROOT_COMMON_PICKER_INJECTION_KEY","useCommonPicker","onPanelChange","getPanel","onSetPickerOption","_createVNode","_mergeProps","onPick","type","parsedValue","value"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBAA,yBAAK,CAACC,MAAN,CAAaC,qCAAb,CAAA,CAAA;AACAF,yBAAK,CAACC,MAAN,CAAaE,8BAAb,CAAA,CAAA;AACAH,yBAAK,CAACC,MAAN,CAAaG,4BAAb,CAAA,CAAA;AACAJ,yBAAK,CAACC,MAAN,CAAaI,6BAAb,CAAA,CAAA;AACAL,yBAAK,CAACC,MAAN,CAAaK,iCAAb,CAAA,CAAA;AACAN,yBAAK,CAACC,MAAN,CAAaM,kCAAb,CAAA,CAAA;AACAP,sBAAAQ,mBAAA,CAAA;AACAR,EAAK,IAACC,EAAN,mBAAA;AAEA,EAAA,OAAA,EAAA,IAAeO;AACbC,EAAAA,OAD6BC,oCAAA;AAE7BC,EAAAA,KAAAA,EAAO,yBAFsB,EAAA,iBAAA,EAAA,cAAA,EAAA,gBAAA,EAAA,MAAA,CAAA;AAG7BC,EAAAA,KAAK,MAHwB,EAAA;IAIxB,KAAE;;GAOF,EAAA;IAAUC,MAAF,EAAA,GAAAC,kBAAA,CAAA,cAAA,CAAA,CAAA;AAASC,IAAAA,MAAAA,eAAAA,GAAAA,UAAAA,CAAAA,mCAAAA,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA;AAAT,IAAiB,IAAAC,iBAAA,CAAA,eAAA,CAAA,EAAA;AAC5B,MAAA,MAAQ,MAAe,GAAAC;AACvB,QAAA;;AACA,MAAAC,WAAe,CAAAC,mCAAmB,EAAA;QAC1BC,KAAAA,EAAAA,MAASH;AAAS,OAAD,CAAvB,CAAA;;eAGO,CAAAI,uCAAA;AACLT,MAAAA,KAAAA;AADiC,MAAA,QAAnC,EAAA,EAAA;AAGD,KAAA,CAAA,CAAA;;MAEM;MACLC,gBADiC;AAEjCS,MAAAA,aAAUC;AAFuB,MAAnC,iBAAA;MAIM,MAAA;QAAAC,UAAA,CAAAC,0CAAA,EAAA,MAAAC,+BAAA,CAAA,KAAA,EAAA,IAAA,CAAA,EAAA,IAAA,CAAA,CAAA;WAAA,MAAA;MAGJC,MAHI,SAAA,GAAAC,mBAAA,CAAA,KAAA,CAAA,IAAA,CAAA,CAAA;MAIJC,OAJIC,eAAA,CAAA,SAAA,EAAAC,cAAA,CAAA,KAAA,EAAA;AAKJC,QAAAA,aAAAA,EAAAA,WAAAA,CAAAA,KAAAA;AALI,QAMFR,qBAAM,EAAA,iBAAA;AAMV,QAAA,mBAAa,EAAA,gBAAA;AACX,QAAA,gBAAkBI,EAAAA,aAAeK;AACjC,QAAA,QAAA,EAAA,MAAA;QAAA,EAGiBC,OAAAA,CAAAA,KAAAA,CAAAA,GAAAA,KAAAA,GAAYC;AAH7B,QAAA,OAAA,EAAA,MAAA,CAAA,KAAA,CAAA;AAAA,OAAA,CAAA,CAAA;AAAA,KAAA,CAAA;;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/instance.d.ts

@@ -0,0 +1,2 @@
+import type DatePickerPanel from './date-picker-panel';
+export type DatePickerPanelInstance = InstanceType<typeof DatePickerPanel> & unknown;

node_modules/element-plus/lib/components/date-picker-panel/src/instance.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=instance.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/instance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

node_modules/element-plus/lib/components/date-picker-panel/src/panel-utils.d.ts

@@ -0,0 +1,525 @@
+import type { DatePickerType } from './types';
+export declare const getPanel: (type: DatePickerType) => ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            readonly disabled: boolean;
+            readonly border: boolean;
+            readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly format: string;
+            readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showConfirm: boolean;
+            readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showWeekNumber: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            readonly parsedValue: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly type: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly dateFormat: StringConstructor;
+            readonly timeFormat: StringConstructor;
+            readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showConfirm: BooleanConstructor;
+            readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showWeekNumber: BooleanConstructor;
+            readonly border: BooleanConstructor;
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onPick?: ((...args: any[]) => any) | undefined;
+            "onPanel-change"?: ((...args: any[]) => any) | undefined;
+            "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "border" | "visible" | "format" | "showNow" | "showConfirm" | "showFooter" | "showWeekNumber">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: import("vue").Slots;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $emit: ((event: "panel-change", ...args: any[]) => void) & ((event: "pick", ...args: any[]) => void) & ((event: "set-picker-option", ...args: any[]) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            readonly parsedValue: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+            readonly type: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly dateFormat: StringConstructor;
+            readonly timeFormat: StringConstructor;
+            readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showConfirm: BooleanConstructor;
+            readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showWeekNumber: BooleanConstructor;
+            readonly border: BooleanConstructor;
+            readonly disabled: BooleanConstructor;
+        }>> & {
+            onPick?: ((...args: any[]) => any) | undefined;
+            "onPanel-change"?: ((...args: any[]) => any) | undefined;
+            "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "panel-change": (...args: any[]) => void;
+            pick: (...args: any[]) => void;
+            "set-picker-option": (...args: any[]) => void;
+        }, string, {
+            readonly disabled: boolean;
+            readonly border: boolean;
+            readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly format: string;
+            readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showConfirm: boolean;
+            readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showWeekNumber: boolean;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        readonly parsedValue: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly type: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly dateFormat: StringConstructor;
+        readonly timeFormat: StringConstructor;
+        readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showConfirm: BooleanConstructor;
+        readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showWeekNumber: BooleanConstructor;
+        readonly border: BooleanConstructor;
+        readonly disabled: BooleanConstructor;
+    }>> & {
+        onPick?: ((...args: any[]) => any) | undefined;
+        "onPanel-change"?: ((...args: any[]) => any) | undefined;
+        "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+}>> & {
+    onPick?: ((...args: any[]) => any) | undefined;
+    "onPanel-change"?: ((...args: any[]) => any) | undefined;
+    "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "panel-change": (...args: any[]) => void;
+    pick: (...args: any[]) => void;
+    "set-picker-option": (...args: any[]) => void;
+}, string, {
+    readonly disabled: boolean;
+    readonly border: boolean;
+    readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly format: string;
+    readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showWeekNumber: boolean;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        sidebar?(_: {
+            class: string;
+        }): any;
+        "prev-year"?(_: {}): any;
+        "prev-month"?(_: {}): any;
+        "next-month"?(_: {}): any;
+        "next-year"?(_: {}): any;
+    };
+})) | ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            readonly disabled: boolean;
+            readonly border: boolean;
+            readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showConfirm: boolean;
+            readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showWeekNumber: boolean;
+            readonly unlinkPanels: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            readonly unlinkPanels: BooleanConstructor;
+            readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showConfirm: BooleanConstructor;
+            readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly border: BooleanConstructor;
+            readonly disabled: BooleanConstructor;
+            readonly parsedValue: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly dateFormat: StringConstructor;
+            readonly timeFormat: StringConstructor;
+            readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showWeekNumber: BooleanConstructor;
+        }>> & {
+            onPick?: ((...args: any[]) => any) | undefined;
+            "onCalendar-change"?: ((...args: any[]) => any) | undefined;
+            "onPanel-change"?: ((...args: any[]) => any) | undefined;
+            "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "border" | "visible" | "showNow" | "showConfirm" | "showFooter" | "showWeekNumber" | "unlinkPanels">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: import("vue").Slots;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $emit: ((event: "calendar-change", ...args: any[]) => void) & ((event: "panel-change", ...args: any[]) => void) & ((event: "pick", ...args: any[]) => void) & ((event: "set-picker-option", ...args: any[]) => void);
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            readonly unlinkPanels: BooleanConstructor;
+            readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showConfirm: BooleanConstructor;
+            readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly border: BooleanConstructor;
+            readonly disabled: BooleanConstructor;
+            readonly parsedValue: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+                readonly required: true;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly dateFormat: StringConstructor;
+            readonly timeFormat: StringConstructor;
+            readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showWeekNumber: BooleanConstructor;
+        }>> & {
+            onPick?: ((...args: any[]) => any) | undefined;
+            "onCalendar-change"?: ((...args: any[]) => any) | undefined;
+            "onPanel-change"?: ((...args: any[]) => any) | undefined;
+            "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+        }, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "calendar-change": (...args: any[]) => void;
+            "panel-change": (...args: any[]) => void;
+            pick: (...args: any[]) => void;
+            "set-picker-option": (...args: any[]) => void;
+        }, string, {
+            readonly disabled: boolean;
+            readonly border: boolean;
+            readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showConfirm: boolean;
+            readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showWeekNumber: boolean;
+            readonly unlinkPanels: boolean;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        readonly unlinkPanels: BooleanConstructor;
+        readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showConfirm: BooleanConstructor;
+        readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly border: BooleanConstructor;
+        readonly disabled: BooleanConstructor;
+        readonly parsedValue: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly type: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+            readonly required: true;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly dateFormat: StringConstructor;
+        readonly timeFormat: StringConstructor;
+        readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showWeekNumber: BooleanConstructor;
+    }>> & {
+        onPick?: ((...args: any[]) => any) | undefined;
+        "onCalendar-change"?: ((...args: any[]) => any) | undefined;
+        "onPanel-change"?: ((...args: any[]) => any) | undefined;
+        "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+    } & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+}>> & {
+    onPick?: ((...args: any[]) => any) | undefined;
+    "onCalendar-change"?: ((...args: any[]) => any) | undefined;
+    "onPanel-change"?: ((...args: any[]) => any) | undefined;
+    "onSet-picker-option"?: ((...args: any[]) => any) | undefined;
+}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "calendar-change": (...args: any[]) => void;
+    "panel-change": (...args: any[]) => void;
+    pick: (...args: any[]) => void;
+    "set-picker-option": (...args: any[]) => void;
+}, string, {
+    readonly disabled: boolean;
+    readonly border: boolean;
+    readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showNow: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showWeekNumber: boolean;
+    readonly unlinkPanels: boolean;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        sidebar?(_: {
+            class: string;
+        }): any;
+        "prev-year"?(_: {}): any;
+        "prev-year"?(_: {}): any;
+        "prev-month"?(_: {}): any;
+        "prev-month"?(_: {}): any;
+        "next-year"?(_: {}): any;
+        "next-year"?(_: {}): any;
+        "next-month"?(_: {}): any;
+        "next-month"?(_: {}): any;
+    };
+})) | ({
+    new (...args: any[]): {
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            readonly disabled: boolean;
+            readonly border: boolean;
+            readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showConfirm: boolean;
+            readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly unlinkPanels: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            readonly unlinkPanels: BooleanConstructor;
+            readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showConfirm: BooleanConstructor;
+            readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly border: BooleanConstructor;
+            readonly disabled: BooleanConstructor;
+            readonly parsedValue: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "border" | "visible" | "showConfirm" | "showFooter" | "unlinkPanels">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: import("vue").Slots;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $emit: (event: string, ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            readonly unlinkPanels: BooleanConstructor;
+            readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly showConfirm: BooleanConstructor;
+            readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+            readonly border: BooleanConstructor;
+            readonly disabled: BooleanConstructor;
+            readonly parsedValue: {
+                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            [x: string]: (...args: any[]) => void;
+        }, string, {
+            readonly disabled: boolean;
+            readonly border: boolean;
+            readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly showConfirm: boolean;
+            readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+            readonly unlinkPanels: boolean;
+        }> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        readonly unlinkPanels: BooleanConstructor;
+        readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showConfirm: BooleanConstructor;
+        readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly border: BooleanConstructor;
+        readonly disabled: BooleanConstructor;
+        readonly parsedValue: {
+            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & import("vue").ShallowUnwrapRef<{}> & {} & import("vue").ComponentCustomProperties;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    [x: string]: (...args: any[]) => void;
+}, string, {
+    readonly disabled: boolean;
+    readonly border: boolean;
+    readonly visible: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showConfirm: boolean;
+    readonly showFooter: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly unlinkPanels: boolean;
+}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        sidebar?(_: {
+            class: string;
+        }): any;
+        "prev-year"?(_: {}): any;
+        "prev-year"?(_: {}): any;
+        "next-year"?(_: {}): any;
+        "next-year"?(_: {}): any;
+    };
+}));

node_modules/element-plus/lib/components/date-picker-panel/src/panel-utils.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var panelDatePick = require('./date-picker-com/panel-date-pick.js');
+var panelDateRange = require('./date-picker-com/panel-date-range.js');
+var panelMonthRange = require('./date-picker-com/panel-month-range.js');
+var panelYearRange = require('./date-picker-com/panel-year-range.js');
+
+const getPanel = function(type) {
+  switch (type) {
+    case "daterange":
+    case "datetimerange": {
+      return panelDateRange["default"];
+    }
+    case "monthrange": {
+      return panelMonthRange["default"];
+    }
+    case "yearrange": {
+      return panelYearRange["default"];
+    }
+    default: {
+      return panelDatePick["default"];
+    }
+  }
+};
+
+exports.getPanel = getPanel;
+//# sourceMappingURL=panel-utils.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/panel-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-utils.js","sources":["../../../../../../packages/components/date-picker-panel/src/panel-utils.ts"],"sourcesContent":["import DatePickPanel from './date-picker-com/panel-date-pick.vue'\nimport DateRangePickPanel from './date-picker-com/panel-date-range.vue'\nimport MonthRangePickPanel from './date-picker-com/panel-month-range.vue'\nimport YearRangePickPanel from './date-picker-com/panel-year-range.vue'\n\nimport type { DatePickerType } from './types'\n\nexport const getPanel = function (type: DatePickerType) {\n  switch (type) {\n    case 'daterange':\n    case 'datetimerange': {\n      return DateRangePickPanel\n    }\n    case 'monthrange': {\n      return MonthRangePickPanel\n    }\n    case 'yearrange': {\n      return YearRangePickPanel\n    }\n    default: {\n      return DatePickPanel\n    }\n  }\n}\n"],"names":["DateRangePickPanel","MonthRangePickPanel","YearRangePickPanel","DatePickPanel"],"mappings":";;;;;;;;;AAIY,MAAC,QAAQ,GAAG,SAAS,IAAI,EAAE;AACvC,EAAE,QAAQ,IAAI;AACd,IAAI,KAAK,WAAW,CAAC;AACrB,IAAI,KAAK,eAAe,EAAE;AAC1B,MAAM,OAAOA,yBAAkB,CAAC;AAChC,KAAK;AACL,IAAI,KAAK,YAAY,EAAE;AACvB,MAAM,OAAOC,0BAAmB,CAAC;AACjC,KAAK;AACL,IAAI,KAAK,WAAW,EAAE;AACtB,MAAM,OAAOC,yBAAkB,CAAC;AAChC,KAAK;AACL,IAAI,SAAS;AACb,MAAM,OAAOC,wBAAa,CAAC;AAC3B,KAAK;AACL,GAAG;AACH;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-cell.d.ts

@@ -0,0 +1,12 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { DateCell } from '../types';
+export declare const basicCellProps: {
+    readonly cell: {
+        readonly type: import("vue").PropType<DateCell>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export type BasicCellProps = ExtractPropTypes<typeof basicCellProps>;
+export type BasicCellPropsPublic = __ExtractPublicPropTypes<typeof basicCellProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-cell.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const basicCellProps = runtime.buildProps({
+  cell: {
+    type: runtime.definePropType(Object)
+  }
+});
+
+exports.basicCellProps = basicCellProps;
+//# sourceMappingURL=basic-cell.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-cell.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-cell.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/basic-cell.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { DateCell } from '../types'\n\nexport const basicCellProps = buildProps({\n  cell: {\n    type: definePropType<DateCell>(Object),\n  },\n} as const)\n\nexport type BasicCellProps = ExtractPropTypes<typeof basicCellProps>\nexport type BasicCellPropsPublic = __ExtractPublicPropTypes<\n  typeof basicCellProps\n>\n"],"names":["buildProps","definePropType"],"mappings":";;;;;;AACY,MAAC,cAAc,GAAGA,kBAAU,CAAC;AACzC,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAEC,sBAAc,CAAC,MAAM,CAAC;AAChC,GAAG;AACH,CAAC;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-date-table.d.ts

@@ -0,0 +1,66 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { Dayjs } from 'dayjs';
+export declare const basicDateTableProps: {
+    readonly showWeekNumber: BooleanConstructor;
+    readonly selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<import("./shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<import("./shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly date: {
+        readonly type: import("vue").PropType<Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Dayjs) | (() => Dayjs | null) | ((new (...args: any[]) => Dayjs) | (() => Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Dayjs) | (() => Dayjs | null) | ((new (...args: any[]) => Dayjs) | (() => Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Dayjs | Dayjs[]) | (() => Dayjs | Dayjs[]) | ((new (...args: any[]) => Dayjs | Dayjs[]) | (() => Dayjs | Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./shared").RangeState) | (() => import("./shared").RangeState) | ((new (...args: any[]) => import("./shared").RangeState) | (() => import("./shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    readonly disabled: BooleanConstructor;
+};
+export declare const basicDateTableEmits: string[];
+export type BasicDateTableProps = ExtractPropTypes<typeof basicDateTableProps>;
+export type BasicDateTablePropsPublic = __ExtractPublicPropTypes<typeof basicDateTableProps>;
+export type BasicDateTableEmits = typeof basicDateTableEmits;
+export type RangePickerEmits = {
+    minDate: Dayjs;
+    maxDate: null;
+};
+export type DatePickerEmits = Dayjs;
+export type DatesPickerEmits = Dayjs[];
+export type MonthsPickerEmits = Dayjs[];
+export type YearsPickerEmits = Dayjs[];
+export type WeekPickerEmits = {
+    year: number;
+    week: number;
+    value: string;
+    date: Dayjs;
+};
+export type DateTableEmits = RangePickerEmits | DatePickerEmits | DatesPickerEmits | WeekPickerEmits;

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-date-table.js

@@ -0,0 +1,17 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const basicDateTableProps = runtime.buildProps({
+  ...shared.datePickerSharedProps,
+  showWeekNumber: Boolean,
+  selectionMode: shared.selectionModeWithDefault("date")
+});
+const basicDateTableEmits = ["changerange", "pick", "select"];
+
+exports.basicDateTableEmits = basicDateTableEmits;
+exports.basicDateTableProps = basicDateTableProps;
+//# sourceMappingURL=basic-date-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-date-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-date-table.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/basic-date-table.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\nimport { datePickerSharedProps, selectionModeWithDefault } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\n\nexport const basicDateTableProps = buildProps({\n  ...datePickerSharedProps,\n  showWeekNumber: Boolean,\n  selectionMode: selectionModeWithDefault('date'),\n} as const)\n\nexport const basicDateTableEmits = ['changerange', 'pick', 'select']\n\nexport type BasicDateTableProps = ExtractPropTypes<typeof basicDateTableProps>\nexport type BasicDateTablePropsPublic = __ExtractPublicPropTypes<\n  typeof basicDateTableProps\n>\nexport type BasicDateTableEmits = typeof basicDateTableEmits\n\nexport type RangePickerEmits = { minDate: Dayjs; maxDate: null }\nexport type DatePickerEmits = Dayjs\nexport type DatesPickerEmits = Dayjs[]\nexport type MonthsPickerEmits = Dayjs[]\nexport type YearsPickerEmits = Dayjs[]\nexport type WeekPickerEmits = {\n  year: number\n  week: number\n  value: string\n  date: Dayjs\n}\n\nexport type DateTableEmits =\n  | RangePickerEmits\n  | DatePickerEmits\n  | DatesPickerEmits\n  | WeekPickerEmits\n"],"names":["buildProps","datePickerSharedProps","selectionModeWithDefault"],"mappings":";;;;;;;AAEY,MAAC,mBAAmB,GAAGA,kBAAU,CAAC;AAC9C,EAAE,GAAGC,4BAAqB;AAC1B,EAAE,cAAc,EAAE,OAAO;AACzB,EAAE,aAAa,EAAEC,+BAAwB,CAAC,MAAM,CAAC;AACjD,CAAC,EAAE;AACS,MAAC,mBAAmB,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-month-table.d.ts

@@ -0,0 +1,47 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+export declare const basicMonthTableProps: {
+    selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    cellClassName: {
+        readonly type: import("vue").PropType<import("./shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    disabledDate: {
+        readonly type: import("vue").PropType<import("./shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    date: {
+        readonly type: import("vue").PropType<import("dayjs").Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | ((new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./shared").RangeState) | (() => import("./shared").RangeState) | ((new (...args: any[]) => import("./shared").RangeState) | (() => import("./shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    disabled: BooleanConstructor;
+};
+export type BasicMonthTableProps = ExtractPropTypes<typeof basicMonthTableProps>;
+export type BasicMonthTablePropsPublic = __ExtractPublicPropTypes<typeof basicMonthTableProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-month-table.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const basicMonthTableProps = runtime.buildProps({
+  ...shared.datePickerSharedProps,
+  selectionMode: shared.selectionModeWithDefault("month")
+});
+
+exports.basicMonthTableProps = basicMonthTableProps;
+//# sourceMappingURL=basic-month-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-month-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-month-table.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/basic-month-table.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\nimport { datePickerSharedProps, selectionModeWithDefault } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\n\nexport const basicMonthTableProps = buildProps({\n  ...datePickerSharedProps,\n  selectionMode: selectionModeWithDefault('month'),\n})\n\nexport type BasicMonthTableProps = ExtractPropTypes<typeof basicMonthTableProps>\nexport type BasicMonthTablePropsPublic = __ExtractPublicPropTypes<\n  typeof basicMonthTableProps\n>\n"],"names":["buildProps","datePickerSharedProps","selectionModeWithDefault"],"mappings":";;;;;;;AAEY,MAAC,oBAAoB,GAAGA,kBAAU,CAAC;AAC/C,EAAE,GAAGC,4BAAqB;AAC1B,EAAE,aAAa,EAAEC,+BAAwB,CAAC,OAAO,CAAC;AAClD,CAAC;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-year-table.d.ts

@@ -0,0 +1,47 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+export declare const basicYearTableProps: {
+    readonly selectionMode: import("element-plus/es/utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<import("./shared").CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<import("./shared").DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly date: {
+        readonly type: import("vue").PropType<import("dayjs").Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null) | ((new (...args: any[]) => import("dayjs").Dayjs) | (() => import("dayjs").Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | ((new (...args: any[]) => import("dayjs").Dayjs | import("dayjs").Dayjs[]) | (() => import("dayjs").Dayjs | import("dayjs").Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => import("./shared").RangeState) | (() => import("./shared").RangeState) | ((new (...args: any[]) => import("./shared").RangeState) | (() => import("./shared").RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    readonly disabled: BooleanConstructor;
+};
+export type BasicYearTableProps = ExtractPropTypes<typeof basicYearTableProps>;
+export type BasicYearTablePropsPublic = __ExtractPublicPropTypes<typeof basicYearTableProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-year-table.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const basicYearTableProps = runtime.buildProps({
+  ...shared.datePickerSharedProps,
+  selectionMode: shared.selectionModeWithDefault("year")
+});
+
+exports.basicYearTableProps = basicYearTableProps;
+//# sourceMappingURL=basic-year-table.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/basic-year-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-year-table.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/basic-year-table.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\nimport { datePickerSharedProps, selectionModeWithDefault } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\n\nexport const basicYearTableProps = buildProps({\n  ...datePickerSharedProps,\n  selectionMode: selectionModeWithDefault('year'),\n} as const)\n\nexport type BasicYearTableProps = ExtractPropTypes<typeof basicYearTableProps>\nexport type BasicYearTablePropsPublic = __ExtractPublicPropTypes<\n  typeof basicYearTableProps\n>\n"],"names":["buildProps","datePickerSharedProps","selectionModeWithDefault"],"mappings":";;;;;;;AAEY,MAAC,mBAAmB,GAAGA,kBAAU,CAAC;AAC9C,EAAE,GAAGC,4BAAqB;AAC1B,EAAE,aAAa,EAAEC,+BAAwB,CAAC,MAAM,CAAC;AACjD,CAAC;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/date-picker-panel.d.ts

@@ -0,0 +1,65 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { ModelValueType, SingleOrRange } from 'element-plus/es/components/time-picker';
+import type { DatePickerType } from '../types';
+export declare const datePickerPanelProps: {
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<Function>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly shortcuts: import("element-plus/es/utils").EpPropFinalized<ArrayConstructor, unknown, unknown, () => never[], boolean>;
+    readonly arrowControl: BooleanConstructor;
+    readonly unlinkPanels: BooleanConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: BooleanConstructor;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly type: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => DatePickerType) | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => DatePickerType))[], unknown, unknown, "date", boolean>;
+    readonly clearable: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly disabledHours: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledHours>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledMinutes: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledMinutes>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledSeconds: {
+        readonly type: import("vue").PropType<import("element-plus/es/components/time-picker").GetDisabledSeconds>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly valueFormat: StringConstructor;
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly modelValue: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => ModelValueType) | ((new (...args: any[]) => string | number | Date | string[] | [import("element-plus/es/components/time-picker").DateModelType, import("element-plus/es/components/time-picker").DateModelType]) | (() => ModelValueType))[], unknown, unknown, "", boolean>;
+    readonly defaultValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly defaultTime: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>) | ((new (...args: any[]) => Date | [Date, Date]) | (() => SingleOrRange<Date>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly isRange: BooleanConstructor;
+};
+export type DatePickerPanelProps = ExtractPropTypes<typeof datePickerPanelProps>;
+export type DatePickerPanelPropsPublic = __ExtractPublicPropTypes<typeof datePickerPanelProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/date-picker-panel.js

@@ -0,0 +1,59 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('../../../time-picker/src/props/shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const datePickerPanelProps = runtime.buildProps({
+  valueFormat: String,
+  dateFormat: String,
+  timeFormat: String,
+  disabled: Boolean,
+  modelValue: {
+    type: runtime.definePropType([Date, Array, String, Number]),
+    default: ""
+  },
+  defaultValue: {
+    type: runtime.definePropType([Date, Array])
+  },
+  defaultTime: {
+    type: runtime.definePropType([Date, Array])
+  },
+  isRange: Boolean,
+  ...shared.disabledTimeListsProps,
+  disabledDate: {
+    type: Function
+  },
+  cellClassName: {
+    type: Function
+  },
+  shortcuts: {
+    type: Array,
+    default: () => []
+  },
+  arrowControl: Boolean,
+  unlinkPanels: Boolean,
+  showNow: {
+    type: Boolean,
+    default: true
+  },
+  showConfirm: Boolean,
+  showFooter: Boolean,
+  showWeekNumber: Boolean,
+  type: {
+    type: runtime.definePropType(String),
+    default: "date"
+  },
+  clearable: {
+    type: Boolean,
+    default: true
+  },
+  border: {
+    type: Boolean,
+    default: true
+  }
+});
+
+exports.datePickerPanelProps = datePickerPanelProps;
+//# sourceMappingURL=date-picker-panel.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/date-picker-panel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"date-picker-panel.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/date-picker-panel.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { disabledTimeListsProps } from '@element-plus/components/time-picker/src/props/shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type {\n  ModelValueType,\n  SingleOrRange,\n} from '@element-plus/components/time-picker'\nimport type { DatePickerType } from '../types'\n\nexport const datePickerPanelProps = buildProps({\n  /**\n   * @description optional, format of binding value. If not specified, the binding value will be a Date object\n   */\n  valueFormat: String,\n  /**\n   * @description optional, format of the date displayed in input's inner panel\n   */\n  dateFormat: String,\n  /**\n   * @description optional, format of the time displayed in input's inner panel\n   */\n  timeFormat: String,\n  /**\n   * @description whether picker is disabled\n   */\n  disabled: Boolean,\n  /**\n   * @description binding value, if it is an array, the length should be 2\n   */\n  modelValue: {\n    type: definePropType<ModelValueType>([Date, Array, String, Number]),\n    default: '',\n  },\n  /**\n   * @description optional, default date of the calendar\n   */\n  defaultValue: {\n    type: definePropType<SingleOrRange<Date>>([Date, Array]),\n  },\n  /**\n   * @description optional, the time value to use when selecting date range\n   */\n  defaultTime: {\n    type: definePropType<SingleOrRange<Date>>([Date, Array]),\n  },\n  /**\n   * @description whether to pick a time range\n   */\n  isRange: Boolean,\n  ...disabledTimeListsProps,\n  /**\n   * @description a function determining if a date is disabled with that date as its parameter. Should return a Boolean\n   */\n  disabledDate: {\n    type: Function,\n  },\n  /**\n   * @description set custom className\n   */\n  cellClassName: {\n    type: Function,\n  },\n  /**\n   * @description an object array to set shortcut options\n   */\n  shortcuts: {\n    type: Array,\n    default: () => [],\n  },\n  /**\n   * @description whether to pick time using arrow buttons\n   */\n  arrowControl: Boolean,\n  /**\n   * @description unlink two date-panels in range-picker\n   */\n  unlinkPanels: Boolean,\n  /**\n   * @description whether to show the now button\n   */\n  showNow: {\n    type: Boolean,\n    default: true,\n  },\n  /**\n   * @description whether to show the confirm button\n   */\n  showConfirm: Boolean,\n  /**\n   * @description whether to show footer\n   */\n  showFooter: Boolean,\n  /**\n   * @description whether to show the number of the calendar week\n   */\n  showWeekNumber: Boolean,\n  /**\n   * @description type of the picker\n   */\n  type: {\n    type: definePropType<DatePickerType>(String),\n    default: 'date',\n  },\n  /**\n   * @description whether to show clear button in range mode\n   */\n  clearable: {\n    type: Boolean,\n    default: true,\n  },\n  /**\n   * @description whether the date picker is bordered\n   */\n  border: {\n    type: Boolean,\n    default: true,\n  },\n} as const)\n\nexport type DatePickerPanelProps = ExtractPropTypes<typeof datePickerPanelProps>\nexport type DatePickerPanelPropsPublic = __ExtractPublicPropTypes<\n  typeof datePickerPanelProps\n>\n"],"names":["buildProps","definePropType","disabledTimeListsProps"],"mappings":";;;;;;;AAEY,MAAC,oBAAoB,GAAGA,kBAAU,CAAC;AAC/C,EAAE,WAAW,EAAE,MAAM;AACrB,EAAE,UAAU,EAAE,MAAM;AACpB,EAAE,UAAU,EAAE,MAAM;AACpB,EAAE,QAAQ,EAAE,OAAO;AACnB,EAAE,UAAU,EAAE;AACd,IAAI,IAAI,EAAEC,sBAAc,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACvD,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,EAAE,YAAY,EAAE;AAChB,IAAI,IAAI,EAAEA,sBAAc,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACvC,GAAG;AACH,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAEA,sBAAc,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACvC,GAAG;AACH,EAAE,OAAO,EAAE,OAAO;AAClB,EAAE,GAAGC,6BAAsB;AAC3B,EAAE,YAAY,EAAE;AAChB,IAAI,IAAI,EAAE,QAAQ;AAClB,GAAG;AACH,EAAE,aAAa,EAAE;AACjB,IAAI,IAAI,EAAE,QAAQ;AAClB,GAAG;AACH,EAAE,SAAS,EAAE;AACb,IAAI,IAAI,EAAE,KAAK;AACf,IAAI,OAAO,EAAE,MAAM,EAAE;AACrB,GAAG;AACH,EAAE,YAAY,EAAE,OAAO;AACvB,EAAE,YAAY,EAAE,OAAO;AACvB,EAAE,OAAO,EAAE;AACX,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,WAAW,EAAE,OAAO;AACtB,EAAE,UAAU,EAAE,OAAO;AACrB,EAAE,cAAc,EAAE,OAAO;AACzB,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAED,sBAAc,CAAC,MAAM,CAAC;AAChC,IAAI,OAAO,EAAE,MAAM;AACnB,GAAG;AACH,EAAE,SAAS,EAAE;AACb,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,MAAM,EAAE;AACV,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,CAAC;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-date-pick.d.ts

@@ -0,0 +1,28 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { DayOrDays } from 'element-plus/es/components/time-picker';
+export declare const panelDatePickProps: {
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly format: import("element-plus/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+};
+export type PanelDatePickProps = ExtractPropTypes<typeof panelDatePickProps>;
+export type PanelDatePickPropsPublic = __ExtractPublicPropTypes<typeof panelDatePickProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-date-pick.js

@@ -0,0 +1,24 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const panelDatePickProps = runtime.buildProps({
+  ...shared.panelSharedProps,
+  parsedValue: {
+    type: runtime.definePropType([Object, Array])
+  },
+  visible: {
+    type: Boolean,
+    default: true
+  },
+  format: {
+    type: String,
+    default: ""
+  }
+});
+
+exports.panelDatePickProps = panelDatePickProps;
+//# sourceMappingURL=panel-date-pick.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-date-pick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-date-pick.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/panel-date-pick.ts"],"sourcesContent":["import { buildProps, definePropType } from '@element-plus/utils'\nimport { panelSharedProps } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { DayOrDays } from '@element-plus/components/time-picker'\n\nexport const panelDatePickProps = buildProps({\n  ...panelSharedProps,\n  parsedValue: {\n    type: definePropType<DayOrDays>([Object, Array]),\n  },\n  visible: {\n    type: Boolean,\n    default: true,\n  },\n  format: {\n    type: String,\n    default: '',\n  },\n} as const)\n\nexport type PanelDatePickProps = ExtractPropTypes<typeof panelDatePickProps>\nexport type PanelDatePickPropsPublic = __ExtractPublicPropTypes<\n  typeof panelDatePickProps\n>\n"],"names":["buildProps","panelSharedProps","definePropType"],"mappings":";;;;;;;AAEY,MAAC,kBAAkB,GAAGA,kBAAU,CAAC;AAC7C,EAAE,GAAGC,uBAAgB;AACrB,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAEC,sBAAc,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzC,GAAG;AACH,EAAE,OAAO,EAAE;AACX,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,MAAM,EAAE;AACV,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,OAAO,EAAE,EAAE;AACf,GAAG;AACH,CAAC;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-date-range.d.ts

@@ -0,0 +1,27 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+export declare const panelDateRangeProps: {
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+};
+export type PanelDateRangeProps = ExtractPropTypes<typeof panelDateRangeProps>;
+export type PanelDateRangePropsPublic = __ExtractPublicPropTypes<typeof panelDateRangeProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-date-range.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const panelDateRangeProps = runtime.buildProps({
+  ...shared.panelSharedProps,
+  ...shared.panelRangeSharedProps
+});
+
+exports.panelDateRangeProps = panelDateRangeProps;
+//# sourceMappingURL=panel-date-range.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-date-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-date-range.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/panel-date-range.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\nimport { panelRangeSharedProps, panelSharedProps } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\n\nexport const panelDateRangeProps = buildProps({\n  ...panelSharedProps,\n  ...panelRangeSharedProps,\n} as const)\n\nexport type PanelDateRangeProps = ExtractPropTypes<typeof panelDateRangeProps>\nexport type PanelDateRangePropsPublic = __ExtractPublicPropTypes<\n  typeof panelDateRangeProps\n>\n"],"names":["buildProps","panelSharedProps","panelRangeSharedProps"],"mappings":";;;;;;;AAEY,MAAC,mBAAmB,GAAGA,kBAAU,CAAC;AAC9C,EAAE,GAAGC,uBAAgB;AACrB,EAAE,GAAGC,4BAAqB;AAC1B,CAAC;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-month-range.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+export declare const panelMonthRangeProps: {
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export declare const panelMonthRangeEmits: string[];
+export type PanelMonthRangeProps = ExtractPropTypes<typeof panelMonthRangeProps>;
+export type PanelMonthRangePropsPublic = __ExtractPublicPropTypes<typeof panelMonthRangeProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-month-range.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const panelMonthRangeProps = runtime.buildProps({
+  ...shared.panelRangeSharedProps
+});
+const panelMonthRangeEmits = [
+  "pick",
+  "set-picker-option",
+  "calendar-change"
+];
+
+exports.panelMonthRangeEmits = panelMonthRangeEmits;
+exports.panelMonthRangeProps = panelMonthRangeProps;
+//# sourceMappingURL=panel-month-range.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-month-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-month-range.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/panel-month-range.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\nimport { panelRangeSharedProps } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\n\nexport const panelMonthRangeProps = buildProps({\n  ...panelRangeSharedProps,\n} as const)\n\nexport const panelMonthRangeEmits = [\n  'pick',\n  'set-picker-option',\n  'calendar-change',\n]\n\nexport type PanelMonthRangeProps = ExtractPropTypes<typeof panelMonthRangeProps>\nexport type PanelMonthRangePropsPublic = __ExtractPublicPropTypes<\n  typeof panelMonthRangeProps\n>\n"],"names":["buildProps","panelRangeSharedProps"],"mappings":";;;;;;;AAEY,MAAC,oBAAoB,GAAGA,kBAAU,CAAC;AAC/C,EAAE,GAAGC,4BAAqB;AAC1B,CAAC,EAAE;AACS,MAAC,oBAAoB,GAAG;AACpC,EAAE,MAAM;AACR,EAAE,mBAAmB;AACrB,EAAE,iBAAiB;AACnB;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-year-range.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+export declare const panelYearRangeProps: {
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays) | ((new (...args: any[]) => import("dayjs").Dayjs | [import("dayjs").Dayjs, import("dayjs").Dayjs]) | (() => import("element-plus").DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export declare const panelYearRangeEmits: string[];
+export type PanelYearRangeProps = ExtractPropTypes<typeof panelYearRangeProps>;
+export type PanelYearRangePropsPublic = __ExtractPublicPropTypes<typeof panelYearRangeProps>;

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-year-range.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shared = require('./shared.js');
+var runtime = require('../../../../utils/vue/props/runtime.js');
+
+const panelYearRangeProps = runtime.buildProps({
+  ...shared.panelRangeSharedProps
+});
+const panelYearRangeEmits = [
+  "pick",
+  "set-picker-option",
+  "calendar-change"
+];
+
+exports.panelYearRangeEmits = panelYearRangeEmits;
+exports.panelYearRangeProps = panelYearRangeProps;
+//# sourceMappingURL=panel-year-range.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/panel-year-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"panel-year-range.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/panel-year-range.ts"],"sourcesContent":["import { buildProps } from '@element-plus/utils'\nimport { panelRangeSharedProps } from './shared'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\n\nexport const panelYearRangeProps = buildProps({\n  ...panelRangeSharedProps,\n} as const)\n\nexport const panelYearRangeEmits = [\n  'pick',\n  'set-picker-option',\n  'calendar-change',\n]\n\nexport type PanelYearRangeProps = ExtractPropTypes<typeof panelYearRangeProps>\nexport type PanelYearRangePropsPublic = __ExtractPublicPropTypes<\n  typeof panelYearRangeProps\n>\n"],"names":["buildProps","panelRangeSharedProps"],"mappings":";;;;;;;AAEY,MAAC,mBAAmB,GAAGA,kBAAU,CAAC;AAC9C,EAAE,GAAGC,4BAAqB;AAC1B,CAAC,EAAE;AACS,MAAC,mBAAmB,GAAG;AACnC,EAAE,MAAM;AACR,EAAE,mBAAmB;AACrB,EAAE,iBAAiB;AACnB;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/props/shared.d.ts

@@ -0,0 +1,95 @@
+import type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue';
+import type { Dayjs } from 'dayjs';
+import type { DayOrDays } from 'element-plus/es/components/time-picker';
+declare const selectionModes: string[];
+export type RangeState = {
+    endDate: null | Dayjs;
+    selecting: boolean;
+};
+export type DisabledDateType = (date: Date) => boolean;
+export type CellClassNameType = (date: Date) => string;
+export declare const datePickerSharedProps: {
+    readonly cellClassName: {
+        readonly type: import("vue").PropType<CellClassNameType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly disabledDate: {
+        readonly type: import("vue").PropType<DisabledDateType>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly date: {
+        readonly type: import("vue").PropType<Dayjs>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly minDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Dayjs) | (() => Dayjs | null) | ((new (...args: any[]) => Dayjs) | (() => Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly maxDate: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Dayjs) | (() => Dayjs | null) | ((new (...args: any[]) => Dayjs) | (() => Dayjs | null))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Dayjs | Dayjs[]) | (() => Dayjs | Dayjs[]) | ((new (...args: any[]) => Dayjs | Dayjs[]) | (() => Dayjs | Dayjs[]))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly rangeState: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => RangeState) | (() => RangeState) | ((new (...args: any[]) => RangeState) | (() => RangeState))[], unknown, unknown, () => {
+        endDate: null;
+        selecting: boolean;
+    }, boolean>;
+    readonly disabled: BooleanConstructor;
+};
+export declare const panelSharedProps: {
+    readonly type: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | ((new (...args: any[]) => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange") | (() => "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange"))[], "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange", unknown>>;
+        readonly required: true;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly dateFormat: StringConstructor;
+    readonly timeFormat: StringConstructor;
+    readonly showNow: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showWeekNumber: BooleanConstructor;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+};
+export declare const panelRangeSharedProps: {
+    readonly unlinkPanels: BooleanConstructor;
+    readonly visible: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showConfirm: BooleanConstructor;
+    readonly showFooter: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly border: BooleanConstructor;
+    readonly disabled: BooleanConstructor;
+    readonly parsedValue: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => Dayjs | [Dayjs, Dayjs]) | (() => DayOrDays) | ((new (...args: any[]) => Dayjs | [Dayjs, Dayjs]) | (() => DayOrDays))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export declare const selectionModeWithDefault: (mode: (typeof selectionModes)[number]) => {
+    type: StringConstructor;
+    values: string[];
+    default: string;
+};
+export declare const rangePickerSharedEmits: {
+    pick: (range: [Dayjs, Dayjs]) => boolean;
+};
+export type RangePickerSharedEmits = typeof rangePickerSharedEmits;
+export type PanelRangeSharedProps = ExtractPropTypes<typeof panelRangeSharedProps>;
+export type PanelRangeSharedPropsPublic = __ExtractPublicPropTypes<typeof panelRangeSharedProps>;
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/props/shared.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var runtime = require('../../../../utils/vue/props/runtime.js');
+var date = require('../../../../constants/date.js');
+var shared = require('@vue/shared');
+
+const selectionModes = [
+  "date",
+  "dates",
+  "year",
+  "years",
+  "month",
+  "months",
+  "week",
+  "range"
+];
+const datePickerSharedProps = runtime.buildProps({
+  cellClassName: {
+    type: runtime.definePropType(Function)
+  },
+  disabledDate: {
+    type: runtime.definePropType(Function)
+  },
+  date: {
+    type: runtime.definePropType(Object),
+    required: true
+  },
+  minDate: {
+    type: runtime.definePropType(Object)
+  },
+  maxDate: {
+    type: runtime.definePropType(Object)
+  },
+  parsedValue: {
+    type: runtime.definePropType([Object, Array])
+  },
+  rangeState: {
+    type: runtime.definePropType(Object),
+    default: () => ({
+      endDate: null,
+      selecting: false
+    })
+  },
+  disabled: Boolean
+});
+const panelSharedProps = runtime.buildProps({
+  type: {
+    type: runtime.definePropType(String),
+    required: true,
+    values: date.datePickTypes
+  },
+  dateFormat: String,
+  timeFormat: String,
+  showNow: {
+    type: Boolean,
+    default: true
+  },
+  showConfirm: Boolean,
+  showFooter: {
+    type: Boolean,
+    default: true
+  },
+  showWeekNumber: Boolean,
+  border: Boolean,
+  disabled: Boolean
+});
+const panelRangeSharedProps = runtime.buildProps({
+  unlinkPanels: Boolean,
+  visible: {
+    type: Boolean,
+    default: true
+  },
+  showConfirm: Boolean,
+  showFooter: {
+    type: Boolean,
+    default: true
+  },
+  border: Boolean,
+  disabled: Boolean,
+  parsedValue: {
+    type: runtime.definePropType(Array)
+  }
+});
+const selectionModeWithDefault = (mode) => {
+  return {
+    type: String,
+    values: selectionModes,
+    default: mode
+  };
+};
+const rangePickerSharedEmits = {
+  pick: (range) => shared.isArray(range)
+};
+
+exports.datePickerSharedProps = datePickerSharedProps;
+exports.panelRangeSharedProps = panelRangeSharedProps;
+exports.panelSharedProps = panelSharedProps;
+exports.rangePickerSharedEmits = rangePickerSharedEmits;
+exports.selectionModeWithDefault = selectionModeWithDefault;
+//# sourceMappingURL=shared.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/props/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","sources":["../../../../../../../packages/components/date-picker-panel/src/props/shared.ts"],"sourcesContent":["import { buildProps, definePropType, isArray } from '@element-plus/utils'\nimport { datePickTypes } from '@element-plus/constants'\n\nimport type { ExtractPropTypes, __ExtractPublicPropTypes } from 'vue'\nimport type { Dayjs } from 'dayjs'\nimport type { DatePickType } from '@element-plus/constants'\nimport type { DayOrDays } from '@element-plus/components/time-picker'\n\nconst selectionModes = [\n  'date',\n  'dates',\n  'year',\n  'years',\n  'month',\n  'months',\n  'week',\n  'range',\n]\n\nexport type RangeState = {\n  endDate: null | Dayjs\n  selecting: boolean\n}\n\nexport type DisabledDateType = (date: Date) => boolean\nexport type CellClassNameType = (date: Date) => string\n\nexport const datePickerSharedProps = buildProps({\n  cellClassName: {\n    type: definePropType<CellClassNameType>(Function),\n  },\n  disabledDate: {\n    type: definePropType<DisabledDateType>(Function),\n  },\n  date: {\n    type: definePropType<Dayjs>(Object),\n    required: true,\n  },\n  minDate: {\n    type: definePropType<Dayjs | null>(Object),\n  },\n  maxDate: {\n    type: definePropType<Dayjs | null>(Object),\n  },\n  parsedValue: {\n    type: definePropType<Dayjs | Dayjs[]>([Object, Array]),\n  },\n  rangeState: {\n    type: definePropType<RangeState>(Object),\n    default: () => ({\n      endDate: null,\n      selecting: false,\n    }),\n  },\n  disabled: Boolean,\n} as const)\n\nexport const panelSharedProps = buildProps({\n  type: {\n    type: definePropType<DatePickType>(String),\n    required: true,\n    values: datePickTypes,\n  },\n  dateFormat: String,\n  timeFormat: String,\n  showNow: {\n    type: Boolean,\n    default: true,\n  },\n  showConfirm: Boolean,\n  showFooter: {\n    type: Boolean,\n    default: true,\n  },\n  showWeekNumber: Boolean,\n  border: Boolean,\n  disabled: Boolean,\n} as const)\n\nexport const panelRangeSharedProps = buildProps({\n  unlinkPanels: Boolean,\n  visible: {\n    type: Boolean,\n    default: true,\n  },\n  showConfirm: Boolean,\n  showFooter: {\n    type: Boolean,\n    default: true,\n  },\n  border: Boolean,\n  disabled: Boolean,\n  parsedValue: {\n    type: definePropType<DayOrDays>(Array),\n  },\n} as const)\n\nexport const selectionModeWithDefault = (\n  mode: typeof selectionModes[number]\n) => {\n  return {\n    type: String,\n    values: selectionModes,\n    default: mode,\n  }\n}\n\nexport const rangePickerSharedEmits = {\n  pick: (range: [Dayjs, Dayjs]) => isArray(range),\n}\n\nexport type RangePickerSharedEmits = typeof rangePickerSharedEmits\nexport type PanelRangeSharedProps = ExtractPropTypes<\n  typeof panelRangeSharedProps\n>\nexport type PanelRangeSharedPropsPublic = __ExtractPublicPropTypes<\n  typeof panelRangeSharedProps\n>\n"],"names":["buildProps","definePropType","datePickTypes","isArray"],"mappings":";;;;;;;;AAEA,MAAM,cAAc,GAAG;AACvB,EAAE,MAAM;AACR,EAAE,OAAO;AACT,EAAE,MAAM;AACR,EAAE,OAAO;AACT,EAAE,OAAO;AACT,EAAE,QAAQ;AACV,EAAE,MAAM;AACR,EAAE,OAAO;AACT,CAAC,CAAC;AACU,MAAC,qBAAqB,GAAGA,kBAAU,CAAC;AAChD,EAAE,aAAa,EAAE;AACjB,IAAI,IAAI,EAAEC,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,EAAE,YAAY,EAAE;AAChB,IAAI,IAAI,EAAEA,sBAAc,CAAC,QAAQ,CAAC;AAClC,GAAG;AACH,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAChC,IAAI,QAAQ,EAAE,IAAI;AAClB,GAAG;AACH,EAAE,OAAO,EAAE;AACX,IAAI,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAChC,GAAG;AACH,EAAE,OAAO,EAAE;AACX,IAAI,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAChC,GAAG;AACH,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAEA,sBAAc,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;AACzC,GAAG;AACH,EAAE,UAAU,EAAE;AACd,IAAI,IAAI,EAAEA,sBAAc,CAAC,MAAM,CAAC;AAChC,IAAI,OAAO,EAAE,OAAO;AACpB,MAAM,OAAO,EAAE,IAAI;AACnB,MAAM,SAAS,EAAE,KAAK;AACtB,KAAK,CAAC;AACN,GAAG;AACH,EAAE,QAAQ,EAAE,OAAO;AACnB,CAAC,EAAE;AACS,MAAC,gBAAgB,GAAGD,kBAAU,CAAC;AAC3C,EAAE,IAAI,EAAE;AACR,IAAI,IAAI,EAAEC,sBAAc,CAAC,MAAM,CAAC;AAChC,IAAI,QAAQ,EAAE,IAAI;AAClB,IAAI,MAAM,EAAEC,kBAAa;AACzB,GAAG;AACH,EAAE,UAAU,EAAE,MAAM;AACpB,EAAE,UAAU,EAAE,MAAM;AACpB,EAAE,OAAO,EAAE;AACX,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,WAAW,EAAE,OAAO;AACtB,EAAE,UAAU,EAAE;AACd,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,cAAc,EAAE,OAAO;AACzB,EAAE,MAAM,EAAE,OAAO;AACjB,EAAE,QAAQ,EAAE,OAAO;AACnB,CAAC,EAAE;AACS,MAAC,qBAAqB,GAAGF,kBAAU,CAAC;AAChD,EAAE,YAAY,EAAE,OAAO;AACvB,EAAE,OAAO,EAAE;AACX,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,WAAW,EAAE,OAAO;AACtB,EAAE,UAAU,EAAE;AACd,IAAI,IAAI,EAAE,OAAO;AACjB,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG;AACH,EAAE,MAAM,EAAE,OAAO;AACjB,EAAE,QAAQ,EAAE,OAAO;AACnB,EAAE,WAAW,EAAE;AACf,IAAI,IAAI,EAAEC,sBAAc,CAAC,KAAK,CAAC;AAC/B,GAAG;AACH,CAAC,EAAE;AACS,MAAC,wBAAwB,GAAG,CAAC,IAAI,KAAK;AAClD,EAAE,OAAO;AACT,IAAI,IAAI,EAAE,MAAM;AAChB,IAAI,MAAM,EAAE,cAAc;AAC1B,IAAI,OAAO,EAAE,IAAI;AACjB,GAAG,CAAC;AACJ,EAAE;AACU,MAAC,sBAAsB,GAAG;AACtC,EAAE,IAAI,EAAE,CAAC,KAAK,KAAKE,cAAO,CAAC,KAAK,CAAC;AACjC;;;;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/src/types.d.ts

@@ -0,0 +1,22 @@
+import type { Dayjs } from 'dayjs';
+export type DatePickerType = 'year' | 'years' | 'month' | 'months' | 'date' | 'dates' | 'week' | 'datetime' | 'datetimerange' | 'daterange' | 'monthrange' | 'yearrange';
+type DateCellType = 'normal' | 'today' | 'week' | 'next-month' | 'prev-month';
+export interface DateCell {
+    column?: number;
+    customClass?: string;
+    disabled?: boolean;
+    end?: boolean;
+    inRange?: boolean;
+    row?: number;
+    selected?: Dayjs;
+    isCurrent?: boolean;
+    isSelected?: boolean;
+    start?: boolean;
+    text?: number;
+    renderText?: string;
+    timestamp?: number;
+    date?: Date;
+    dayjs?: Dayjs;
+    type?: DateCellType;
+}
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/types.js

@@ -0,0 +1,3 @@
+'use strict';
+
+//# sourceMappingURL=types.js.map

node_modules/element-plus/lib/components/date-picker-panel/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}

node_modules/element-plus/lib/components/date-picker-panel/src/utils.d.ts

@@ -0,0 +1,38 @@
+import dayjs from 'dayjs';
+import type { ComputedRef } from 'vue';
+import type { Dayjs } from 'dayjs';
+import type { DateCell } from './types';
+import type { DisabledDateType } from './props/shared';
+type DayRange = [Dayjs | undefined, Dayjs | undefined];
+export declare const isValidRange: (range: DayRange) => boolean;
+type GetDefaultValueParams = {
+    lang: string;
+    step?: number;
+    unit: 'month' | 'year';
+    unlinkPanels: boolean;
+};
+export type DefaultValue = [Date, Date] | Date | undefined;
+export declare const getDefaultValue: (defaultValue: DefaultValue, { lang, step, unit, unlinkPanels }: GetDefaultValueParams) => dayjs.Dayjs[];
+type Dimension = {
+    row: number;
+    column: number;
+};
+type BuildPickerTableMetadata = {
+    startDate?: Dayjs | null;
+    unit: 'month' | 'day';
+    columnIndexOffset: number;
+    now: Dayjs;
+    nextEndDate: Dayjs | null;
+    relativeDateGetter: (index: number) => Dayjs;
+    setCellMetadata?: (cell: DateCell, dimension: {
+        rowIndex: number;
+        columnIndex: number;
+    }) => void;
+    setRowMetadata?: (row: DateCell[]) => void;
+};
+export declare const buildPickerTable: (dimension: Dimension, rows: DateCell[][], { columnIndexOffset, startDate, nextEndDate, now, unit, relativeDateGetter, setCellMetadata, setRowMetadata, }: BuildPickerTableMetadata) => void;
+export declare const datesInMonth: (date: Dayjs, year: number, month: number, lang: string) => Date[];
+export declare const getValidDateOfMonth: (date: Dayjs, year: number, month: number, lang: string, disabledDate?: DisabledDateType) => dayjs.Dayjs;
+export declare const getValidDateOfYear: (value: Dayjs, lang: string, disabledDate?: DisabledDateType) => dayjs.Dayjs;
+export declare const correctlyParseUserInput: (value: string | Dayjs | Dayjs[], format: string, lang: string, defaultFormat: ComputedRef<boolean> | undefined) => Dayjs | Dayjs[];
+export {};

node_modules/element-plus/lib/components/date-picker-panel/src/utils.js

@@ -0,0 +1,134 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dayjs = require('dayjs');
+var shared = require('@vue/shared');
+var utils = require('../../time-picker/src/utils.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
+
+const isValidRange = (range) => {
+  if (!shared.isArray(range))
+    return false;
+  const [left, right] = range;
+  return dayjs__default["default"].isDayjs(left) && dayjs__default["default"].isDayjs(right) && dayjs__default["default"](left).isValid() && dayjs__default["default"](right).isValid() && left.isSameOrBefore(right);
+};
+const getDefaultValue = (defaultValue, { lang, step = 1, unit, unlinkPanels }) => {
+  let start;
+  if (shared.isArray(defaultValue)) {
+    let [left, right] = defaultValue.map((d) => dayjs__default["default"](d).locale(lang));
+    if (!unlinkPanels) {
+      right = left.add(step, unit);
+    }
+    return [left, right];
+  } else if (defaultValue) {
+    start = dayjs__default["default"](defaultValue);
+  } else {
+    start = dayjs__default["default"]();
+  }
+  start = start.locale(lang);
+  return [start, start.add(step, unit)];
+};
+const buildPickerTable = (dimension, rows, {
+  columnIndexOffset,
+  startDate,
+  nextEndDate,
+  now,
+  unit,
+  relativeDateGetter,
+  setCellMetadata,
+  setRowMetadata
+}) => {
+  for (let rowIndex = 0; rowIndex < dimension.row; rowIndex++) {
+    const row = rows[rowIndex];
+    for (let columnIndex = 0; columnIndex < dimension.column; columnIndex++) {
+      let cell = row[columnIndex + columnIndexOffset];
+      if (!cell) {
+        cell = {
+          row: rowIndex,
+          column: columnIndex,
+          type: "normal",
+          inRange: false,
+          start: false,
+          end: false
+        };
+      }
+      const index = rowIndex * dimension.column + columnIndex;
+      const nextStartDate = relativeDateGetter(index);
+      cell.dayjs = nextStartDate;
+      cell.date = nextStartDate.toDate();
+      cell.timestamp = nextStartDate.valueOf();
+      cell.type = "normal";
+      cell.inRange = !!(startDate && nextStartDate.isSameOrAfter(startDate, unit) && nextEndDate && nextStartDate.isSameOrBefore(nextEndDate, unit)) || !!(startDate && nextStartDate.isSameOrBefore(startDate, unit) && nextEndDate && nextStartDate.isSameOrAfter(nextEndDate, unit));
+      if (startDate == null ? void 0 : startDate.isSameOrAfter(nextEndDate)) {
+        cell.start = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit);
+        cell.end = startDate && nextStartDate.isSame(startDate, unit);
+      } else {
+        cell.start = !!startDate && nextStartDate.isSame(startDate, unit);
+        cell.end = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit);
+      }
+      const isToday = nextStartDate.isSame(now, unit);
+      if (isToday) {
+        cell.type = "today";
+      }
+      setCellMetadata == null ? void 0 : setCellMetadata(cell, { rowIndex, columnIndex });
+      row[columnIndex + columnIndexOffset] = cell;
+    }
+    setRowMetadata == null ? void 0 : setRowMetadata(row);
+  }
+};
+const datesInMonth = (date, year, month, lang) => {
+  const firstDay = dayjs__default["default"]().locale(lang).startOf("month").month(month).year(year).hour(date.hour()).minute(date.minute()).second(date.second());
+  const numOfDays = firstDay.daysInMonth();
+  return utils.rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
+};
+const getValidDateOfMonth = (date, year, month, lang, disabledDate) => {
+  const _value = dayjs__default["default"]().year(year).month(month).startOf("month").hour(date.hour()).minute(date.minute()).second(date.second());
+  const _date = datesInMonth(date, year, month, lang).find((date2) => {
+    return !(disabledDate == null ? void 0 : disabledDate(date2));
+  });
+  if (_date) {
+    return dayjs__default["default"](_date).locale(lang);
+  }
+  return _value.locale(lang);
+};
+const getValidDateOfYear = (value, lang, disabledDate) => {
+  const year = value.year();
+  if (!(disabledDate == null ? void 0 : disabledDate(value.toDate()))) {
+    return value.locale(lang);
+  }
+  const month = value.month();
+  if (!datesInMonth(value, year, month, lang).every(disabledDate)) {
+    return getValidDateOfMonth(value, year, month, lang, disabledDate);
+  }
+  for (let i = 0; i < 12; i++) {
+    if (!datesInMonth(value, year, i, lang).every(disabledDate)) {
+      return getValidDateOfMonth(value, year, i, lang, disabledDate);
+    }
+  }
+  return value;
+};
+const correctlyParseUserInput = (value, format, lang, defaultFormat) => {
+  if (shared.isArray(value)) {
+    return value.map((v) => correctlyParseUserInput(v, format, lang, defaultFormat));
+  }
+  if (shared.isString(value)) {
+    const dayjsValue = (defaultFormat == null ? void 0 : defaultFormat.value) ? dayjs__default["default"](value) : dayjs__default["default"](value, format);
+    if (!dayjsValue.isValid()) {
+      return dayjsValue;
+    }
+  }
+  return dayjs__default["default"](value, format).locale(lang);
+};
+
+exports.buildPickerTable = buildPickerTable;
+exports.correctlyParseUserInput = correctlyParseUserInput;
+exports.datesInMonth = datesInMonth;
+exports.getDefaultValue = getDefaultValue;
+exports.getValidDateOfMonth = getValidDateOfMonth;
+exports.getValidDateOfYear = getValidDateOfYear;
+exports.isValidRange = isValidRange;
+//# sourceMappingURL=utils.js.map

node_modules/element-plus/lib/components/date-picker-panel/style/css.d.ts

@@ -0,0 +1,5 @@
+import 'element-plus/es/components/base/style/css';
+import 'element-plus/theme-chalk/el-date-picker-panel.css';
+import 'element-plus/es/components/input/style/css';
+import 'element-plus/es/components/scrollbar/style/css';
+import 'element-plus/es/components/button/style/css';

node_modules/element-plus/lib/components/date-picker-panel/style/css.js

@@ -0,0 +1,9 @@
+'use strict';
+
+require('../../base/style/css.js');
+require('element-plus/theme-chalk/el-date-picker-panel.css');
+require('../../input/style/css.js');
+require('../../scrollbar/style/css.js');
+require('../../button/style/css.js');
+
+//# sourceMappingURL=css.js.map

node_modules/element-plus/lib/components/date-picker-panel/style/css.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}

node_modules/element-plus/lib/components/date-picker-panel/style/index.d.ts

@@ -0,0 +1,5 @@
+import 'element-plus/es/components/base/style';
+import 'element-plus/theme-chalk/src/date-picker-panel.scss';
+import 'element-plus/es/components/input/style';
+import 'element-plus/es/components/scrollbar/style';
+import 'element-plus/es/components/button/style';

node_modules/element-plus/lib/components/date-picker-panel/style/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+require('../../base/style/index.js');
+require('element-plus/theme-chalk/src/date-picker-panel.scss');
+require('../../input/style/index.js');
+require('../../scrollbar/style/index.js');
+require('../../button/style/index.js');
+
+//# sourceMappingURL=index.js.map

node_modules/element-plus/lib/components/date-picker-panel/style/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;"}