/**
 * ldesign v0.2.14
 * (c) 2022/11/2 16:16 built by swimly
 * @license MIT
 */

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var helper$1 = require('../../chunks/helper.js');
var dayjs = require('dayjs');
var _commonjsHelpers = require('../../chunks/_commonjsHelpers.js');
var helper = require('../../chunks/helper2.js');
var utils_mixins = require('../../utils/mixins.js');
var components_configProvider_configReceiver = require('../config-provider/config-receiver.js');
var utils_event = require('../../utils/event.js');
var components_select_index = require('../select/index.js');
var components_radio_index = require('../radio/index.js');
var components_button_index = require('../button/index.js');
var components_tag_index = require('../tag/index.js');
var utils_renderComponent = require('../../utils/render-component.js');
var utils_renderNode = require('../../utils/render-node.js');
var components_calendar_calendarCell = require('./calendar-cell.js');
var components_calendar_const = require('./const.js');
var components_calendar_utils = require('./utils.js');
var components_calendar_props = require('./props.js');
require('vue');
require('lodash/mergeWith');
require('lodash');
require('../config-provider/context.js');
require('../../chunks/zh_CN.js');
require('../../utils/helper.js');
require('lodash/camelCase');
require('@vue/composition-api');
require('../../utils/with-install.js');
require('../../config.js');
require('../select/select.js');
require('lodash/isFunction');
require('lodash/debounce');
require('lodash/get');
require('lodash/cloneDeep');
require('lodash/isArray');
require('lodash/isObject');
require('../../chunks/log.js');
require('../../chunks/_commonjsHelpers-2e6815bd.js');
require('../../hooks/use-default-value.js');
require('../../hooks/use-vmodel.js');
require('lodash/kebabCase');
require('../../hooks/lnode.js');
require('lodash/isEmpty');
require('../../hooks/render-lnode.js');
require('../config-provider/useConfig.js');
require('../loading/index.js');
require('../loading/loading.js');
require('../../utils/dom.js');
require('raf');
require('lodash/isString');
require('../../utils/easing.js');
require('../../utils/transfer-dom.js');
require('../loading/props.js');
require('../loading/icon/gradient.js');
require('../../chunks/defineProperty-838e4192.js');
require('../../chunks/set-style.js');
require('../loading/plugin.js');
require('../popup/index.js');
require('../../utils/map-props.js');
require('../popup/popup.js');
require('@popperjs/core');
require('../popup/props.js');
require('../popup/container.js');
require('../input/index.js');
require('../input/input.js');
require('@ldesign/icons-vue');
require('../input/props.js');
require('../input/group.js');
require('../select-input/index.js');
require('../select-input/select-input.js');
require('../select-input/props.js');
require('../select-input/hooks/use-single.js');
require('lodash/pick');
require('../../hooks/use-config.js');
require('../select-input/hooks/use-multiple.js');
require('../tag-input/index.js');
require('../tag-input/tag-input.js');
require('../../hooks/use-global-icon.js');
require('../tag-input/props.js');
require('../tag-input/hooks/use-tag-scroll.js');
require('../tag-input/hooks/use-tag-list.js');
require('../tag-input/hooks/use-hover.js');
require('../tag-input/hooks/use-drag-sorter.js');
require('../tag/tag.js');
require('../tag/props.js');
require('../tag/check-tag.js');
require('../select-input/hooks/use-overlay-innerstyle.js');
require('../common/fake-arrow.js');
require('../../hooks/use-form-disabled.js');
require('../select/option.js');
require('../../utils/ripple.js');
require('../checkbox/index.js');
require('../checkbox/group.js');
require('lodash/intersection');
require('../checkbox/checkbox.js');
require('../checkbox/props.js');
require('../../hooks/use-lazy-load.js');
require('../../chunks/observe.js');
require('../../hooks/use-common-classname.js');
require('../select/utils.js');
require('../select/props.js');
require('../select/select-panel.js');
require('../../hooks/use-virtual-scroll.js');
require('../select/hooks/use-select-options.js');
require('../select/option-group.js');
require('../radio/radio.js');
require('../radio/props.js');
require('../radio/group.js');
require('lodash/isNumber');
require('../radio/radio-button.js');
require('../button/button.js');
require('../button/props.js');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }

var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);

var calendar$1 = {exports: {}};

(function (module, exports) {
  !function (e, t) {
    module.exports = t() ;
  }(_commonjsHelpers.commonjsGlobal, function () {

    return function (e, t, a) {
      var n = "h:mm A",
        d = {
          lastDay: "[Yesterday at] " + n,
          sameDay: "[Today at] " + n,
          nextDay: "[Tomorrow at] " + n,
          nextWeek: "dddd [at] " + n,
          lastWeek: "[Last] dddd [at] " + n,
          sameElse: "MM/DD/YYYY"
        };
      t.prototype.calendar = function (e, t) {
        var n = t || this.$locale().calendar || d,
          o = a(e || void 0).startOf("d"),
          s = this.diff(o, "d", !0),
          i = "sameElse",
          f = s < -6 ? i : s < -1 ? "lastWeek" : s < 0 ? "lastDay" : s < 1 ? "sameDay" : s < 2 ? "nextDay" : s < 7 ? "nextWeek" : i,
          l = n[f] || d[f];
        return "function" == typeof l ? l.call(this, a()) : this.format(l);
      };
    };
  });
})(calendar$1);
var calendar = calendar$1.exports;

dayjs__default["default"].extend(calendar);
const createDefaultCurDate = () => dayjs__default["default"](dayjs__default["default"]().format("YYYY-MM-DD"));
const getDefaultControllerConfigData = function () {
  let visible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
  return {
    visible,
    disabled: false,
    mode: {
      visible: true,
      radioGroupProps: {}
    },
    year: {
      visible: true,
      selectProps: {}
    },
    month: {
      visible: true,
      selectProps: {}
    },
    weekend: {
      visible: true,
      showWeekendButtonProps: {},
      hideWeekendButtonProps: {}
    },
    current: {
      visible: true,
      currentDayButtonProps: {},
      currentMonthButtonProps: {}
    }
  };
};
var _Calendar = utils_mixins["default"](components_configProvider_configReceiver["default"]("calendar")).extend({
  name: "LCalendar",
  components: {
    TCheckTag: components_tag_index.CheckTag,
    TSelect: components_select_index.Select,
    TOption: components_select_index.Option,
    TRadioGroup: components_radio_index.RadioGroup,
    TRadioButton: components_radio_index.RadioButton,
    TButton: components_button_index.Button,
    CalendarCellItem: components_calendar_calendarCell["default"],
    RenderComponent: utils_renderComponent["default"]
  },
  props: {
    ...components_calendar_props["default"]
  },
  data() {
    return {
      curDate: null,
      curSelectedYear: null,
      curSelectedMonth: null,
      curSelectedMode: null,
      isShowWeekend: true,
      controlSize: "medium"
    };
  },
  computed: {
    realFirstDayOfWeek() {
      return this.firstDayOfWeek ?? this.global.firstDayOfWeek ?? 1;
    },
    TEXT_MAP() {
      const {
        t,
        global
      } = this;
      const r = {
        showWeekend: t(global.showWeekend),
        hideWeekend: t(global.hideWeekend),
        today: t(global.today),
        thisMonth: t(global.thisMonth)
      };
      return r;
    },
    weekDipalyText() {
      return this.week || this.t(this.global.week).split(",");
    },
    calendarCls() {
      return [`${this.componentName}`, `${this.componentName}--${this.theme}`];
    },
    calendarPanelCls() {
      return [`${this.componentName}__panel`, `${this.componentName}__panel--${this.curSelectedMode}`];
    },
    isWeekRender() {
      return typeof this.week === "function";
    },
    rangeFromTo() {
      if (!this.range || this.range.length < 2) return null;
      const [v1, v2] = this.range;
      if (dayjs__default["default"](v1).isBefore(dayjs__default["default"](v2))) {
        return {
          from: v1,
          to: v2
        };
      }
      return {
        from: v2,
        to: v1
      };
    },
    controllerOptions() {
      const dayJsFilterDate = dayjs__default["default"](`${this.curSelectedYear}-${this.curSelectedMonth}`);
      const re = {
        isShowWeekend: this.isShowWeekend,
        filterDate: dayJsFilterDate.toDate(),
        formattedFilterDate: dayJsFilterDate.format(this.format),
        mode: this.curSelectedMode
      };
      return re;
    },
    cellColHeaders() {
      const re = [];
      const min = 1;
      const max = 7;
      for (let i = this.realFirstDayOfWeek; i <= max; i++) {
        re.push({
          num: i,
          display: this.getWeekDisplay(i)
        });
      }
      if (this.realFirstDayOfWeek > min) {
        for (let i = min; i < this.realFirstDayOfWeek; i++) {
          re.push({
            num: i,
            display: this.getWeekDisplay(i)
          });
        }
      }
      return re;
    },
    yearSelectOptionList() {
      const re = [];
      let begin = this.curSelectedYear - 10;
      let end = this.curSelectedYear + 10;
      if (this.rangeFromTo && this.rangeFromTo.from && this.rangeFromTo.to) {
        begin = dayjs__default["default"](this.rangeFromTo.from).year();
        end = dayjs__default["default"](this.rangeFromTo.to).year();
      }
      if (begin < components_calendar_const.MIN_YEAR) begin = components_calendar_const.MIN_YEAR;
      if (end < components_calendar_const.MIN_YEAR) end = components_calendar_const.MIN_YEAR;
      for (let i = begin; i <= end; i++) {
        const disabled = this.checkMonthAndYearSelecterDisabled(i, this.curSelectedMonth);
        re.push({
          value: i,
          label: this.t(this.global.yearSelection, {
            year: i
          }),
          disabled
        });
      }
      return re;
    },
    monthSelectOptionList() {
      const re = [];
      for (let i = components_calendar_const.FIRST_MONTH_OF_YEAR; i <= components_calendar_const.LAST_MONTH_OF_YEAR; i++) {
        const disabled = this.checkMonthAndYearSelecterDisabled(this.curSelectedYear, i);
        re.push({
          value: i,
          label: this.t(this.global.monthSelection, {
            month: i
          }),
          disabled
        });
      }
      return re;
    },
    modeSelectOptionList() {
      return [{
        value: "month",
        label: this.t(this.global.monthRadio)
      }, {
        value: "year",
        label: this.t(this.global.yearRadio)
      }];
    },
    monthCellsData() {
      const {
        realFirstDayOfWeek
      } = this;
      const daysArr = components_calendar_utils.createMonthCellsData(this.curSelectedYear, this.curSelectedMonth, realFirstDayOfWeek, this.curDate, this.format);
      return daysArr;
    },
    yearCellsData() {
      const re = [];
      const monthsArr = components_calendar_utils.createYearCellsData(this.curSelectedYear, this.curDate, this.format);
      const rowCount = Math.ceil(monthsArr.length / components_calendar_const.DEFAULT_YEAR_CELL_NUMINROW);
      let index = 0;
      for (let i = 1; i <= rowCount; i++) {
        const row = [];
        for (let j = 1; j <= components_calendar_const.DEFAULT_YEAR_CELL_NUMINROW; j++) {
          row.push(monthsArr[index]);
          index += 1;
        }
        re.push(row);
      }
      return re;
    },
    controllerConfigData() {
      const controllerConfig = this.controllerConfig ?? this.global.controllerConfig ?? true;
      if (typeof controllerConfig === "boolean") return getDefaultControllerConfigData(controllerConfig);
      return {
        ...getDefaultControllerConfigData(),
        ...controllerConfig
      };
    },
    isControllerVisible() {
      return this.controllerConfigData && this.controllerConfigData.visible;
    },
    weekendBtnText() {
      return this.isShowWeekend ? this.TEXT_MAP.hideWeekend : this.TEXT_MAP.showWeekend;
    },
    weekendBtnVBind() {
      const c = this.controllerConfigData.weekend;
      return this.isShowWeekend ? c.hideWeekendButtonProps : c.showWeekendButtonProps;
    },
    currentBtnText() {
      return this.curSelectedMode === "month" ? this.TEXT_MAP.today : this.TEXT_MAP.thisMonth;
    },
    currentBtnVBind() {
      const c = this.controllerConfigData.current;
      return this.curSelectedMode === "month" ? c.currentDayButtonProps : c.currentMonthButtonProps;
    },
    isModeVisible() {
      return this.checkControllerVisible("mode");
    },
    isYearVisible() {
      return this.checkControllerVisible("year");
    },
    isMonthVisible() {
      return this.checkControllerVisible("month");
    },
    isWeekendToggleVisible() {
      return this.checkControllerVisible("weekend");
    },
    isCurrentBtnVisible() {
      return this.checkControllerVisible("current");
    },
    isModeDisabled() {
      return this.checkControllerDisabled("mode", "radioGroupProps");
    },
    isYearDisabled() {
      return this.checkControllerDisabled("year", "selectProps");
    },
    isMonthDisabled() {
      return this.checkControllerDisabled("month", "selectProps");
    },
    isWeekendToggleDisabled() {
      const p = this.isShowWeekend ? "hideWeekendButtonProps" : "showWeekendButtonProps";
      return this.checkControllerDisabled("weekend", p);
    },
    isCurrentBtnDisabled() {
      const p = this.curSelectedMode === "month" ? "currentDayButtonProps" : "currentMonthButtonProps";
      return this.checkControllerDisabled("current", p);
    },
    filterYearStr() {
      return `${this.controllerOptions.filterDate.getFullYear()}`;
    },
    filterMonthStr() {
      return `${this.controllerOptions.filterDate.getMonth() + 1}`;
    },
    filterYearMonth() {
      return {
        year: this.filterYearStr,
        month: this.filterMonthStr
      };
    }
  },
  watch: {
    value: {
      handler(v) {
        this.setCurrentDate(v);
      },
      immediate: true
    },
    year: {
      handler(v) {
        this.setCurSelectedYear(v);
      },
      immediate: true
    },
    month: {
      handler(v) {
        this.setCurSelectedMonth(v);
      },
      immediate: true
    },
    mode: {
      handler(v) {
        this.curSelectedMode = v;
      },
      immediate: true
    },
    isShowWeekendDefault: {
      handler(v) {
        this.isShowWeekend = v;
      },
      immediate: true
    },
    filterYearMonth: {
      handler(v) {
        utils_event.emitEvent(this, "month-change", v);
        this.controllerChange();
      }
    },
    curSelectedMode() {
      this.handleIE();
    },
    isShowWeekend() {
      this.handleIE();
    },
    isControllerVisible() {
      this.handleIE();
    }
  },
  mounted() {
    this.handleIE();
  },
  methods: {
    handleIE() {
      if (helper.getIEVersion() <= 9) {
        this.$nextTick(() => {
          const element = this.$el.children[this.isControllerVisible ? 1 : 0];
          if (this.curSelectedMode === "month") element.setAttribute("is-show-weekend", `${this.isShowWeekend}`);else element.removeAttribute("is-show-weekend");
        });
      }
    },
    getCalendarWeekSlotData(item) {
      return {
        day: item.num
      };
    },
    getWeekDisplay(weekNum) {
      const weekText = this.weekDipalyText;
      return typeof weekText === "object" && weekText[weekNum - 1] ? weekText[weekNum - 1] : components_calendar_utils.getDayCn(weekNum);
    },
    checkMonthCellItemShowed(cellData) {
      return this.isShowWeekend || cellData.day < 6;
    },
    createCalendarCell(cellData) {
      return {
        ...cellData,
        ...this.controllerOptions
      };
    },
    clickCell(e, cellData) {
      this.curDate = dayjs__default["default"](cellData.date);
      const options = this.getCellClickEventOptions(e, cellData);
      utils_event.emitEvent(this, "cell-click", options);
    },
    doubleClickCell(e, cellData) {
      const options = this.getCellClickEventOptions(e, cellData);
      utils_event.emitEvent(this, "cell-double-click", options);
    },
    rightClickCell(e, cellData) {
      if (this.preventCellContextmenu) e.preventDefault();
      const options = this.getCellClickEventOptions(e, cellData);
      utils_event.emitEvent(this, "cell-right-click", options);
    },
    getCellClickEventOptions(e, cellData) {
      return {
        cell: this.createCalendarCell(cellData),
        e
      };
    },
    controllerChange() {
      const options = this.controllerOptions;
      utils_event.emitEvent(this, "controller-change", options);
    },
    onWeekendToggleClick() {
      this.isShowWeekend = !this.isShowWeekend;
      this.controllerChange();
    },
    checkMonthCellColHeaderVisibled(item) {
      let re = true;
      if (!this.isShowWeekend) re = item.num !== 6 && item.num !== 7;
      return re;
    },
    checkControllerDisabled(name, propsName) {
      let re = false;
      const conf = this.controllerConfigData;
      if (conf && (conf.disabled || conf[name] && conf[name][propsName] && conf[name][propsName].disabled)) re = true;
      return re;
    },
    checkControllerVisible(name) {
      let re = true;
      const conf = this.controllerConfigData;
      if (!conf || !conf.visible || conf[name] === false || conf[name] && !conf[name].visible) re = false;
      return re;
    },
    toToday() {
      const currentSelectDate = createDefaultCurDate();
      this.curSelectedYear = currentSelectDate.year();
      this.curSelectedMonth = parseInt(currentSelectDate.format("M"), 10);
    },
    setCurSelectedYear(year) {
      const curSelectedYear = year ? parseInt(`${year}`, 10) : createDefaultCurDate().year();
      if (!isNaN(curSelectedYear) && curSelectedYear > 0) this.curSelectedYear = curSelectedYear;
    },
    setCurSelectedMonth(month) {
      const curSelectedMonth = month ? parseInt(`${month}`, 10) : parseInt(createDefaultCurDate().format("M"), 10);
      if (!isNaN(curSelectedMonth) && curSelectedMonth > 0 && curSelectedMonth <= 12) this.curSelectedMonth = curSelectedMonth;
    },
    setCurrentDate(value) {
      this.curDate = value ? dayjs__default["default"](value) : createDefaultCurDate();
    },
    checkMonthAndYearSelecterDisabled(year, month) {
      let disabled = false;
      if (this.rangeFromTo && this.rangeFromTo.from && this.rangeFromTo.to) {
        const beginYear = dayjs__default["default"](this.rangeFromTo.from).year();
        const endYear = dayjs__default["default"](this.rangeFromTo.to).year();
        if (year === beginYear) {
          const beginMon = parseInt(dayjs__default["default"](this.rangeFromTo.from).format("M"), 10);
          disabled = month < beginMon;
        } else if (year === endYear) {
          const endMon = parseInt(dayjs__default["default"](this.rangeFromTo.to).format("M"), 10);
          disabled = month > endMon;
        }
      }
      return disabled;
    },
    renderControl() {
      const h = this.$createElement;
      const {
        controllerOptions
      } = this;
      return h("div", {
        "class": `${this.componentName}__control`
      }, [h("div", {
        "class": `${this.componentName}__title`
      }, [utils_renderNode.renderLNodeJSX(this, "head", {
        params: controllerOptions
      })]), h("div", {
        "class": `${this.componentName}__control-section`
      }, [this.isYearVisible && h("div", {
        "class": `${this.componentName}__control-section-cell`
      }, [h("t-select", helper$1.helper([{
        "attrs": {
          "size": this.controlSize,
          "disabled": this.isYearDisabled,
          "autoWidth": true
        }
      }, {
        "props": {
          ...this.controllerConfigData.year.selectProps
        }
      }, {
        "model": {
          value: this.curSelectedYear,
          callback: $$v => {
            this.curSelectedYear = $$v;
          }
        }
      }]), [this.yearSelectOptionList.map(item => h("t-option", {
        "key": item.value,
        "attrs": {
          "value": item.value,
          "label": item.label,
          "disabled": item.disabled
        }
      }, [item.label]))])]), this.curSelectedMode === "month" && this.isMonthVisible && h("div", {
        "class": `${this.componentName}__control-section-cell`
      }, [h("t-select", helper$1.helper([{
        "attrs": {
          "size": this.controlSize,
          "disabled": this.isMonthDisabled,
          "autoWidth": true
        }
      }, {
        "props": {
          ...this.controllerConfigData.month.selectProps
        }
      }, {
        "model": {
          value: this.curSelectedMonth,
          callback: $$v => {
            this.curSelectedMonth = $$v;
          }
        }
      }]), [this.monthSelectOptionList.map(item => h("t-option", {
        "key": item.value,
        "attrs": {
          "value": item.value,
          "label": item.label,
          "disabled": item.disabled
        }
      }, [item.label]))])]), this.isModeVisible && h("div", {
        "class": `${this.componentName}__control-section-cell`,
        "style": "height: auto"
      }, [h("t-radio-group", helper$1.helper([{
        "attrs": {
          "variant": "default-filled",
          "size": this.controlSize,
          "disabled": this.isModeDisabled
        }
      }, {
        "props": {
          ...this.controllerConfigData.mode.radioGroupProps
        }
      }, {
        "on": {
          "change": this.controllerChange
        },
        "model": {
          value: this.curSelectedMode,
          callback: $$v => {
            this.curSelectedMode = $$v;
          }
        }
      }]), [this.modeSelectOptionList.map(item => h("t-radio-button", {
        "key": item.value,
        "attrs": {
          "value": item.value
        }
      }, [item.label]))])]), this.theme === "full" && this.curSelectedMode === "month" && this.isWeekendToggleVisible && h("div", {
        "class": `${this.componentName}__control-section-cell`
      }, [h("t-check-tag", helper$1.helper([{
        "class": `${this.componentName}__control-tag`,
        "attrs": {
          "defaultChecked": !this.isShowWeekend,
          "disabled": this.isWeekendToggleDisabled
        },
        "on": {
          "click": this.onWeekendToggleClick
        }
      }, {
        "props": {
          ...this.weekendBtnVBind
        }
      }]), [this.weekendBtnText])]), this.theme === "full" && this.isCurrentBtnVisible && h("div", {
        "class": `${this.componentName}__control-section-cell`
      }, [h("t-button", helper$1.helper([{
        "attrs": {
          "size": this.controlSize,
          "disabled": this.isCurrentBtnDisabled
        },
        "on": {
          "click": () => {
            this.toToday();
          }
        }
      }, {
        "props": {
          ...this.currentBtnVBind
        }
      }]), [this.currentBtnText])])])]);
    }
  },
  render() {
    const h = arguments[0];
    const {
      calendarCls,
      calendarPanelCls,
      isControllerVisible,
      cellColHeaders,
      checkMonthCellColHeaderVisibled
    } = this;
    const monthBody = () => h("table", {
      "class": `${this.componentName}__table`
    }, [h("thead", {
      "class": `${this.componentName}__table-head`
    }, [h("tr", {
      "class": `${this.componentName}__table-head-row`
    }, [cellColHeaders.map((item, index) => checkMonthCellColHeaderVisibled(item) && h("th", {
      "class": `${this.componentName}__table-head-cell`
    }, [Array.isArray(this.week) ? this.week[index] : utils_renderNode.renderLNodeJSXDefault(this, "week", {
      defaultNode: h("span", [item.display]),
      params: this.getCalendarWeekSlotData(item)
    })]))])]), h("tbody", {
      "class": `${this.componentName}__table-body`
    }, [this.monthCellsData.map((week, weekIndex) => h("tr", {
      "class": `${this.componentName}__table-body-row`
    }, [week.map((item, itemIndex) => this.checkMonthCellItemShowed(item) && h("calendar-cell-item", {
      "key": `d-${weekIndex}-${itemIndex}`,
      "attrs": {
        "item": item,
        "theme": this.theme,
        "t": this.t,
        "global": this.global,
        "cell": this.cell,
        "fillWithZero": this.fillWithZero
      },
      "on": {
        "click": e => this.clickCell(e, item),
        "dblclick": e => this.doubleClickCell(e, item),
        "rightclick": e => this.rightClickCell(e, item)
      },
      "scopedSlots": {
        ...this.$scopedSlots
      }
    }))]))])]);
    const yearBody = () => h("table", {
      "class": `${this.componentName}__table`
    }, [h("tbody", {
      "class": `${this.componentName}__table-body`
    }, [this.yearCellsData.map((cell, cellIndex) => h("tr", {
      "class": `${this.componentName}__table-body-row`
    }, [cell.map((item, itemIndex) => h("calendar-cell-item", {
      "key": `m-${cellIndex}-${itemIndex}`,
      "attrs": {
        "item": item,
        "theme": this.theme,
        "t": this.t,
        "global": this.global,
        "cell": this.cell,
        "fillWithZero": this.fillWithZero
      },
      "on": {
        "click": e => this.clickCell(e, item),
        "dblclick": e => this.doubleClickCell(e, item),
        "rightclick": e => this.rightClickCell(e, item)
      },
      "scopedSlots": {
        ...this.$scopedSlots
      }
    }))]))])]);
    return h("div", {
      "class": calendarCls
    }, [isControllerVisible && this.renderControl(), h("div", {
      "class": calendarPanelCls
    }, [this.curSelectedMode === "month" ? monthBody() : yearBody()])]);
  }
});

exports["default"] = _Calendar;
//# sourceMappingURL=calendar.js.map
