@ditojs/admin 2.93.0 → 2.94.1

package/src/utils/ui/dist/dito-ui.umd.js

@@ -0,0 +1,2744 @@
+;(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined'
+    ? factory(exports, require('@ditojs/utils'))
+    : typeof define === 'function' && define.amd
+      ? define(['exports', '@ditojs/utils'], factory)
+      : ((global =
+          typeof globalThis !== 'undefined' ? globalThis : global || self),
+        factory((global['dito-ui'] = {}), global['@ditojs/utils']))
+})(this, function (exports2, utils) {
+  'use strict'
+  const index = ''
+  function getAbsoluteBoundingRect(el) {
+    const doc = document
+    const win = window
+    const body = doc.body
+    let offsetX =
+      win.pageXOffset !== void 0
+        ? win.pageXOffset
+        : (doc.documentElement || body.parentNode || body).scrollLeft
+    let offsetY =
+      win.pageYOffset !== void 0
+        ? win.pageYOffset
+        : (doc.documentElement || body.parentNode || body).scrollTop
+    const rect = el.getBoundingClientRect()
+    if (el !== body) {
+      let parent = el.parentNode
+      while (parent !== body) {
+        offsetX += parent.scrollLeft
+        offsetY += parent.scrollTop
+        parent = parent.parentNode
+      }
+    }
+    return {
+      bottom: rect.bottom + offsetY,
+      height: rect.height,
+      left: rect.left + offsetX,
+      right: rect.right + offsetX,
+      top: rect.top + offsetY,
+      width: rect.width
+    }
+  }
+  function copyDate(date, {
+    year,
+    month,
+    day,
+    hour,
+    minute,
+    second,
+    millisecond
+  } = {}) {
+    return new Date(
+      utils.pick(year, date && date.getFullYear(), 0),
+      utils.pick(month, date && date.getMonth(), 0),
+      utils.pick(day, date && date.getDate(), 0),
+      utils.pick(hour, date && date.getHours(), 0),
+      utils.pick(minute, date && date.getMinutes(), 0),
+      utils.pick(second, date && date.getSeconds(), 0),
+      utils.pick(millisecond, date && date.getMilliseconds(), 0)
+    )
+  }
+  function convertDate(date) {
+    return utils.isDate(date) ? date : date ? new Date(date) : null
+  }
+  function addEvents(target, events2) {
+    for (const type in events2) {
+      target.addEventListener(type, events2[type], false)
+    }
+    return {
+      remove() {
+        for (const type in events2) {
+          target.removeEventListener(type, events2[type], false)
+        }
+      }
+    }
+  }
+  function getKey(event) {
+    return {
+      37: 'left',
+      38: 'up',
+      39: 'right',
+      40: 'down',
+      13: 'enter'
+    }[event.keyCode]
+  }
+  function getKeyNavigation(event) {
+    const key = getKey(event)
+    return {
+      hor: { left: -1, right: 1 }[key] || 0,
+      ver: { up: -1, down: 1 }[key] || 0,
+      enter: key === 'enter'
+    }
+  }
+  function scrollTo(element, to, duration) {
+    const requestAnimationFrame = (
+      window.requestAnimationFrame ||
+      function () {
+        return setTimeout(arguments[0], 10)
+      }
+    )
+    if (duration <= 0) {
+      element.scrollTop = to
+    } else {
+      const difference = to - element.scrollTop
+      const perTick = difference / duration * 10
+      requestAnimationFrame(() => {
+        element.scrollTop = element.scrollTop + perTick
+        if (element.scrollTop === to) {
+          return
+        }
+        scrollTo(element, to, duration - 10)
+      })
+    }
+  }
+  function setSelection(field, start, end) {
+    if (field.createTextRange) {
+      const range = field.createTextRange()
+      range.collapse(true)
+      range.moveStart('character', start)
+      range.moveEnd('character', end)
+      range.select()
+      field.focus()
+    } else if (field.setSelectionRange) {
+      field.focus()
+      field.setSelectionRange(start, end)
+    } else if ('selectionStart' in field) {
+      field.selectionStart = start
+      field.selectionEnd = end
+      field.focus()
+    }
+  }
+  const render$8 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c(
+      'div',
+      {
+        staticClass: 'dito-calendar'
+      },
+      [
+        _c(
+          'div',
+          {
+            staticClass: 'dito-calendar-popup'
+          },
+          [
+            _c(
+              'div',
+              {
+                staticClass: 'dito-calendar-inner'
+              },
+              [
+                _vm.currentMode === 'day'
+                  ? [
+                      _c(
+                        'div',
+                        {
+                          staticClass: 'dito-calendar-header'
+                        },
+                        [
+                          _c('a', {
+                            staticClass:
+                              'dito-calendar-step-prev dito-calendar-step-year',
+                            on: {
+                              click: function ($event) {
+                                return _vm.stepYear(-1)
+                              }
+                            }
+                          }),
+                          _c('a', {
+                            staticClass:
+                              'dito-calendar-step-prev dito-calendar-step-month',
+                            on: {
+                              click: function ($event) {
+                                return _vm.stepMonth(-1)
+                              }
+                            }
+                          }),
+                          _c('span', [
+                            _c(
+                              'a',
+                              {
+                                staticClass: 'dito-calendar-select-year',
+                                on: {
+                                  click: function ($event) {
+                                    return _vm.setMode('year')
+                                  }
+                                }
+                              },
+                              [
+                                _vm._v(
+                                  _vm._s(
+                                    _vm.dateToString(_vm.currentValue, {
+                                      year: 1
+                                    })
+                                  )
+                                )
+                              ]
+                            ),
+                            _c(
+                              'a',
+                              {
+                                staticClass: 'dito-calendar-select-month',
+                                on: {
+                                  click: function ($event) {
+                                    return _vm.setMode('month')
+                                  }
+                                }
+                              },
+                              [
+                                _vm._v(
+                                  _vm._s(
+                                    _vm.dateToString(_vm.currentValue, {
+                                      month: 1
+                                    })
+                                  )
+                                )
+                              ]
+                            )
+                          ]),
+                          _c('a', {
+                            staticClass:
+                              'dito-calendar-step-next dito-calendar-step-month',
+                            on: {
+                              click: function ($event) {
+                                return _vm.stepMonth(1)
+                              }
+                            }
+                          }),
+                          _c('a', {
+                            staticClass:
+                              'dito-calendar-step-next dito-calendar-step-year',
+                            on: {
+                              click: function ($event) {
+                                return _vm.stepYear(1)
+                              }
+                            }
+                          })
+                        ]
+                      ),
+                      _c(
+                        'div',
+                        {
+                          staticClass: 'dito-calendar-body'
+                        },
+                        [
+                          _c(
+                            'div',
+                            {
+                              staticClass: 'dito-calendar-weekdays'
+                            },
+                            _vm._l(_vm.weekdayNames, function (weekday) {
+                              return _c('span', [_vm._v(_vm._s(weekday.short))])
+                            }),
+                            0
+                          ),
+                          _c(
+                            'div',
+                            {
+                              staticClass: 'dito-calendar-dates'
+                            },
+                            _vm._l(_vm.dateRange, function (date) {
+                              return _c(
+                                'span',
+                                {
+                                  class: (
+                                    date.state && `dito-calendar-item-${
+                                      date.state
+                                    }`
+                                  ),
+                                  on: {
+                                    click: function ($event) {
+                                      return _vm.selectDate(
+                                        date.date,
+                                        date.state,
+                                        true
+                                      )
+                                    }
+                                  }
+                                },
+                                [_vm._v(_vm._s(date.text))]
+                              )
+                            }),
+                            0
+                          )
+                        ]
+                      ),
+                      _c(
+                        'div',
+                        {
+                          staticClass: 'dito-calendar-footer'
+                        },
+                        [
+                          _c('a', {
+                            staticClass: 'dito-calendar-select-today',
+                            attrs: {
+                              role: 'button',
+                              title: _vm.dateToString(new Date(), {
+                                year: 1,
+                                month: 1,
+                                day: 1
+                              })
+                            },
+                            on: {
+                              click: function ($event) {
+                                _vm.selectDate(new Date())
+                              }
+                            }
+                          })
+                        ]
+                      )
+                    ]
+                  : _vm.currentMode === 'month'
+                    ? [
+                        _c(
+                          'div',
+                          {
+                            staticClass: 'dito-calendar-header'
+                          },
+                          [
+                            _c('a', {
+                              staticClass: 'dito-calendar-step-prev',
+                              on: {
+                                click: function ($event) {
+                                  return _vm.stepYear(-1)
+                                }
+                              }
+                            }),
+                            _c('span', [
+                              _c(
+                                'a',
+                                {
+                                  staticClass: 'dito-calendar-select-year',
+                                  on: {
+                                    click: function ($event) {
+                                      return _vm.setMode('year')
+                                    }
+                                  }
+                                },
+                                [
+                                  _vm._v(
+                                    _vm._s(
+                                      _vm.dateToString(_vm.currentValue, {
+                                        year: 1
+                                      })
+                                    )
+                                  )
+                                ]
+                              )
+                            ]),
+                            _c('a', {
+                              staticClass: 'dito-calendar-step-next',
+                              on: {
+                                click: function ($event) {
+                                  return _vm.stepYear(1)
+                                }
+                              }
+                            })
+                          ]
+                        ),
+                        _c(
+                          'div',
+                          {
+                            staticClass: 'dito-calendar-body'
+                          },
+                          [
+                            _c(
+                              'div',
+                              {
+                                staticClass: 'dito-calendar-months'
+                              },
+                              _vm._l(_vm.monthNames, function (month, index2) {
+                                return _c(
+                                  'span',
+                                  {
+                                    class: _vm.getMonthClass(index2),
+                                    on: {
+                                      click: function ($event) {
+                                        return _vm.selectMonth(index2)
+                                      }
+                                    }
+                                  },
+                                  [_vm._v(_vm._s(month.short))]
+                                )
+                              }),
+                              0
+                            )
+                          ]
+                        )
+                      ]
+                    : _vm.currentMode === 'year'
+                      ? [
+                          _c(
+                            'div',
+                            {
+                              staticClass: 'dito-calendar-header'
+                            },
+                            [
+                              _c('a', {
+                                staticClass: 'dito-calendar-step-prev',
+                                on: {
+                                  click: function ($event) {
+                                    return _vm.stepDecade(-1)
+                                  }
+                                }
+                              }),
+                              _c('span', [
+                                _vm._v(
+                                  _vm._s(_vm.decadeToString(_vm.currentValue))
+                                )
+                              ]),
+                              _c('a', {
+                                staticClass: 'dito-calendar-step-next',
+                                on: {
+                                  click: function ($event) {
+                                    return _vm.stepDecade(1)
+                                  }
+                                }
+                              })
+                            ]
+                          ),
+                          _c(
+                            'div',
+                            {
+                              staticClass: 'dito-calendar-body'
+                            },
+                            [
+                              _c(
+                                'div',
+                                {
+                                  staticClass: 'dito-calendar-years'
+                                },
+                                _vm._l(_vm.yearRange, function (year) {
+                                  return _c(
+                                    'span',
+                                    {
+                                      class: _vm.getYearClass(year),
+                                      on: {
+                                        click: function ($event) {
+                                          return _vm.selectYear(year)
+                                        }
+                                      }
+                                    },
+                                    [_vm._v(_vm._s(year))]
+                                  )
+                                }),
+                                0
+                              )
+                            ]
+                          )
+                        ]
+                      : _vm._e()
+              ],
+              2
+            )
+          ]
+        )
+      ]
+    )
+  }
+  const staticRenderFns$8 = []
+  render$8._withStripped = true
+  const Calendar_vue_vue_type_style_index_0_lang = ''
+  function normalizeComponent(
+    scriptExports,
+    render2,
+    staticRenderFns2,
+    functionalTemplate,
+    injectStyles,
+    scopeId,
+    moduleIdentifier,
+    shadowMode
+  ) {
+    const options =
+      typeof scriptExports === 'function'
+        ? scriptExports.options
+        : scriptExports
+    if (render2) {
+      options.render = render2
+      options.staticRenderFns = staticRenderFns2
+      options._compiled = true
+    }
+    if (functionalTemplate) {
+      options.functional = true
+    }
+    if (scopeId) {
+      options._scopeId = 'data-v-' + scopeId
+    }
+    let hook
+    if (moduleIdentifier) {
+      hook = function (context) {
+        context = (
+          context ||
+          this.$vnode && this.$vnode.ssrContext ||
+          this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext
+        )
+        if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
+          context = __VUE_SSR_CONTEXT__
+        }
+        if (injectStyles) {
+          injectStyles.call(this, context)
+        }
+        if (context && context._registeredComponents) {
+          context._registeredComponents.add(moduleIdentifier)
+        }
+      }
+      options._ssrRegister = hook
+    } else if (injectStyles) {
+      hook = shadowMode
+        ? function () {
+            injectStyles.call(
+              this,
+              (options.functional ? this.parent : this).$root.$options
+                .shadowRoot
+            )
+          }
+        : injectStyles
+    }
+    if (hook) {
+      if (options.functional) {
+        options._injectStyles = hook
+        const originalRender = options.render
+        options.render = function renderWithStyleInjection(h, context) {
+          hook.call(context)
+          return originalRender(h, context)
+        }
+      } else {
+        const existing = options.beforeCreate
+        options.beforeCreate = existing ? [].concat(existing, hook) : [hook]
+      }
+    }
+    return {
+      exports: scriptExports,
+      options
+    }
+  }
+  const __vue2_script$9 = {
+    props: {
+      value: { type: Date, default: null },
+      locale: { type: String, default: 'en-US' },
+      disabledDate: { type: Function, default: () => false },
+      mode: { type: String, default: 'day' }
+    },
+    data() {
+      const { weekdayNames, monthNames } = getLocaleNames(this.locale)
+      return {
+        weekdayNames,
+        monthNames,
+        dateRange: [],
+        yearRange: [],
+        currentValue: (
+          this.value || copyDate(new Date(), { hour: 0, minute: 0, second: 0 })
+        ),
+        currentMode: this.mode
+      }
+    },
+    watch: {
+      currentValue: 'updateDateRange',
+      disabledDate: 'updateDateRange',
+      value(newVal, oldVal) {
+        if (+newVal !== +oldVal) {
+          this.currentValue = newVal || new Date()
+        }
+      },
+      mode(mode) {
+        this.currentMode = mode
+      }
+    },
+    mounted() {
+      this.updateDateRange()
+    },
+    methods: {
+      getMonthClass(month) {
+        return {
+          'dito-calendar-item-active': (
+            this.value &&
+            month === this.value.getMonth() &&
+            this.currentValue.getFullYear() === this.value.getFullYear()
+          ),
+          'dito-calendar-item-current': month === this.currentValue.getMonth()
+        }
+      },
+      getYearClass(year) {
+        return {
+          'dito-calendar-item-active': (
+            this.value && year === this.value.getFullYear()
+          ),
+          'dito-calendar-item-current': year === this.currentValue.getFullYear()
+        }
+      },
+      setDate(overrides) {
+        this.currentValue = copyDate(this.currentValue, overrides)
+      },
+      stepDecade(step) {
+        this.setDate({
+          year: this.currentValue.getFullYear() + step * 10
+        })
+      },
+      setMode(mode) {
+        this.currentMode = mode
+      },
+      stepMonth(step) {
+        const { currentValue } = this
+        const { year, month } = this.getYearMonth(
+          currentValue.getFullYear(),
+          currentValue.getMonth() + step
+        )
+        this.setDate({
+          month,
+          day: Math.min(
+            this.getDayCount(year, month),
+            this.currentValue.getDate()
+          )
+        })
+      },
+      stepYear(step) {
+        this.setDate({
+          year: this.currentValue.getFullYear() + step
+        })
+      },
+      selectDate(date, state, copy = false) {
+        if (state !== 'disabled') {
+          if (copy) {
+            this.setDate({
+              year: date.getFullYear(),
+              month: date.getMonth(),
+              day: date.getDate()
+            })
+          } else {
+            this.currentValue = date
+          }
+          this.$emit('input', this.currentValue)
+        }
+      },
+      selectMonth(month) {
+        this.setMode('day')
+        this.setDate({ month })
+      },
+      selectYear(year) {
+        this.setMode('month')
+        this.setDate({ year })
+      },
+      getYearMonth(year, month) {
+        if (month > 11) {
+          year++
+          month = 0
+        } else if (month < 0) {
+          year--
+          month = 11
+        }
+        return { year, month }
+      },
+      dateToString(date, { year, month, day }) {
+        return date.toLocaleString(this.locale, {
+          year: year && 'numeric',
+          month: month && 'long',
+          day: day && 'numeric'
+        })
+      },
+      decadeToString(date) {
+        const year = this.getFirstYearOfDecade(date.getFullYear())
+        return `${year} \u2013 ${year + 9}`
+      },
+      getDayCount(year, month) {
+        const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        return month === 1 && (!(year % 400) || !(year % 4) && year % 100)
+          ? 29
+          : daysInMonth[month]
+      },
+      getFirstYearOfDecade(year) {
+        const yearStr = year.toString()
+        return +`${yearStr.slice(0, -1)}0`
+      },
+      navigate({ hor, ver, enter }) {
+        const { currentMode, currentValue } = this
+        if (hor || ver) {
+          switch (currentMode) {
+            case 'day':
+              this.setDate({
+                day: currentValue.getDate() + hor + ver * 7
+              })
+              break
+            case 'month':
+              this.setDate({
+                month: currentValue.getMonth() + hor + ver * 6
+              })
+              break
+            case 'year':
+              this.setDate({
+                year: currentValue.getFullYear() + hor + ver * 5
+              })
+              break
+          }
+          return true
+        } else if (enter) {
+          switch (currentMode) {
+            case 'day':
+              this.selectDate(currentValue)
+              break
+            case 'month':
+              this.setMode('day')
+              break
+            case 'year':
+              this.setMode('month')
+              break
+          }
+          return true
+        }
+      },
+      updateDateRange() {
+        this.dateRange = []
+        this.yearRange = []
+        const { currentValue } = this
+        const year = currentValue.getFullYear()
+        const month = currentValue.getMonth()
+        const startYear = this.getFirstYearOfDecade(year)
+        for (let i = 0; i < 10; i++) {
+          this.yearRange.push(startYear + i)
+        }
+        const currMonthFirstDay = new Date(year, month, 1)
+        let firstDayWeek = currMonthFirstDay.getDay() + 1
+        if (firstDayWeek === 0) {
+          firstDayWeek = 7
+        }
+        const dayCount = this.getDayCount(year, month)
+        if (firstDayWeek > 1) {
+          const prevMonth = this.getYearMonth(year, month - 1)
+          const prevMonthDayCount = this.getDayCount(
+            prevMonth.year,
+            prevMonth.month
+          )
+          for (let i = 1; i < firstDayWeek; i++) {
+            const day = prevMonthDayCount - firstDayWeek + i + 1
+            const date = new Date(prevMonth.year, prevMonth.month, day)
+            this.dateRange.push({
+              text: day,
+              date,
+              state: this.disabledDate(date) ? 'disabled' : 'gray'
+            })
+          }
+        }
+        const today = new Date()
+        for (let i = 1; i <= dayCount; i++) {
+          const date = new Date(year, month, i)
+          const isDay = date2 => (
+            date2 &&
+            date2.getDate() === i &&
+            date2.getFullYear() === year &&
+            date2.getMonth() === month
+          )
+          const state = isDay(this.value)
+            ? 'active'
+            : isDay(today)
+              ? 'today'
+              : this.disabledDate(date)
+                ? 'disabled'
+                : isDay(currentValue)
+                  ? 'current'
+                  : null
+          this.dateRange.push({
+            text: i,
+            date,
+            state
+          })
+        }
+        const nextMonthNeed = 42 - this.dateRange.length
+        if (nextMonthNeed > 0) {
+          const nextMonth = this.getYearMonth(year, month + 1)
+          for (let i = 1; i <= nextMonthNeed; i++) {
+            const date = new Date(nextMonth.year, nextMonth.month, i)
+            const state = this.disabledDate(date) ? 'disabled' : 'gray'
+            this.dateRange.push({
+              text: i,
+              date,
+              state
+            })
+          }
+        }
+      }
+    }
+  }
+  const localeNames = {}
+  function getLocaleNames(locale) {
+    let names = localeNames[locale]
+    if (!names) {
+      const weekdayNames = []
+      for (let i = 0; i < 7; i++) {
+        const date = new Date(0, 0, i)
+        weekdayNames.push({
+          long: date.toLocaleString(locale, { weekday: 'long' }),
+          short: date.toLocaleString(locale, { weekday: 'short' })
+        })
+      }
+      const monthNames = []
+      for (let i = 1; i <= 12; i++) {
+        const date = new Date(0, i, 0)
+        monthNames.push({
+          long: date.toLocaleString(locale, { month: 'long' }),
+          short: date.toLocaleString(locale, { month: 'short' })
+        })
+      }
+      names = localeNames[locale] = {
+        weekdayNames,
+        monthNames
+      }
+    }
+    return names
+  }
+  const __cssModules$9 = {}
+  const __component__$9 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$9,
+    render$8,
+    staticRenderFns$8,
+    false,
+    __vue2_injectStyles$9,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$9(context) {
+    for (const o in __cssModules$9) {
+      this[o] = __cssModules$9[o]
+    }
+  }
+  __component__$9.options.__file = 'src/components/Calendar.vue'
+  const Calendar = /* @__PURE__ */ (function () {
+    return __component__$9.exports
+  })()
+  const render$7 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c(
+      'div',
+      {
+        staticClass: 'dito-trigger-container'
+      },
+      [
+        _vm.alwaysShow
+          ? _c(
+              'div',
+              {
+                ref: 'trigger',
+                staticClass: 'dito-trigger',
+                class: _vm.triggerClass
+              },
+              [_vm._t('trigger')],
+              2
+            )
+          : _vm.trigger === 'click'
+            ? _c(
+                'div',
+                {
+                  ref: 'trigger',
+                  staticClass: 'dito-trigger',
+                  class: _vm.triggerClass,
+                  on: {
+                    click: _vm.onClick
+                  }
+                },
+                [_vm._t('trigger')],
+                2
+              )
+            : _vm.trigger === 'hover'
+              ? _c(
+                  'div',
+                  {
+                    ref: 'trigger',
+                    staticClass: 'dito-trigger',
+                    class: _vm.triggerClass,
+                    on: {
+                      mouseenter: function ($event) {
+                        return _vm.onHover(true)
+                      },
+                      mouseleave: function ($event) {
+                        return _vm.onHover(false)
+                      }
+                    }
+                  },
+                  [_vm._t('trigger')],
+                  2
+                )
+              : _vm.trigger === 'focus' || _vm.trigger === 'always'
+                ? _c(
+                    'div',
+                    {
+                      ref: 'trigger',
+                      staticClass: 'dito-trigger',
+                      class: _vm.triggerClass
+                    },
+                    [_vm._t('trigger')],
+                    2
+                  )
+                : _vm._e(),
+        _c(
+          'transition',
+          {
+            attrs: {
+              name: _vm.transition
+            }
+          },
+          [
+            _vm.trigger === 'hover'
+              ? _c(
+                  'div',
+                  {
+                    directives: [
+                      {
+                        name: 'show',
+                        rawName: 'v-show',
+                        value: _vm.showPopup,
+                        expression: 'showPopup'
+                      }
+                    ],
+                    ref: 'popup',
+                    staticClass: 'dito-popup',
+                    class: _vm.popupClass,
+                    style: _vm.popupStyle,
+                    on: {
+                      mouseenter: function ($event) {
+                        return _vm.onHover(true)
+                      },
+                      mouseleave: function ($event) {
+                        return _vm.onHover(false)
+                      }
+                    }
+                  },
+                  [_vm.showPopup ? _vm._t('popup') : _vm._e()],
+                  2
+                )
+              : _c(
+                  'div',
+                  {
+                    directives: [
+                      {
+                        name: 'show',
+                        rawName: 'v-show',
+                        value: _vm.showPopup,
+                        expression: 'showPopup'
+                      }
+                    ],
+                    ref: 'popup',
+                    staticClass: 'dito-popup',
+                    class: _vm.popupClass,
+                    style: _vm.popupStyle
+                  },
+                  [_vm.showPopup ? _vm._t('popup') : _vm._e()],
+                  2
+                )
+          ]
+        )
+      ],
+      1
+    )
+  }
+  const staticRenderFns$7 = []
+  render$7._withStripped = true
+  const Trigger_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$8 = {
+    props: {
+      trigger: { type: String, default: 'click' },
+      transition: { type: String, default: 'slide' },
+      placement: { type: String, default: 'bottom' },
+      show: { type: Boolean, default: false },
+      disabled: { type: Boolean, default: false },
+      target: { type: [String, HTMLElement], default: null },
+      customClass: { type: String, default: null },
+      zIndex: { type: Number, default: 0 },
+      keepInView: { type: Boolean, default: true },
+      hideWhenClickOutside: { type: Boolean, default: true },
+      alwaysShow: { type: Boolean, default: false },
+      cover: { type: Boolean, default: false },
+      hideDelay: { type: Number, default: 0 }
+    },
+    data() {
+      return {
+        showPopup: this.show,
+        popupPlacement: this.placement
+      }
+    },
+    computed: {
+      triggerClass() {
+        return {
+          'dito-trigger-disabled': this.disabled
+        }
+      },
+      popupClass() {
+        const classes = {
+          [`dito-popup-${utils.hyphenate(this.placement)}`]: true
+        }
+        if (this.customClass) {
+          classes[this.customClass] = true
+        }
+        return classes
+      },
+      popupStyle() {
+        return this.zIndex ? `z-index: ${this.zIndex}` : ''
+      }
+    },
+    watch: {
+      show(show) {
+        this.showPopup = show || this.alwaysShow
+      },
+      showPopup(newVal, oldVal) {
+        if (!newVal !== !oldVal) {
+          this.$emit('update:show', newVal)
+          if (newVal) {
+            this.$nextTick(() => this.updatePosition())
+          }
+        }
+      }
+    },
+    mounted() {
+      const { trigger, popup } = this.$refs
+      if (this.trigger === 'focus') {
+        const target = trigger.querySelector('input, textarea')
+        if (target) {
+          this.focusEvents = addEvents(target, {
+            focus: () => {
+              this.showPopup = true
+            },
+            blur: () => {
+              this.showPopup = false
+            }
+          })
+        }
+      }
+      if (this.hideWhenClickOutside && !this.alwaysShow) {
+        this.closeEvents = addEvents(window, {
+          mouseup: event => {
+            if (
+              this.showPopup &&
+              !popup.contains(event.target) &&
+              !trigger.contains(event.target)
+            ) {
+              this.showPopup = false
+            }
+          },
+          blur: () => {
+            this.showPopup = false
+          }
+        })
+      }
+      if (this.alwaysShow) {
+        this.showPopup = true
+      }
+    },
+    created() {
+      this.showPopup = this.show
+    },
+    beforeDestroy() {
+      let _a, _b
+      ;(_a = this.focusEvents) == null ? void 0 : _a.remove()
+      ;(_b = this.closeEvents) == null ? void 0 : _b.remove()
+      this.mouseLeaveTimer = null
+    },
+    methods: {
+      updatePosition() {
+        const { trigger, popup } = this.$refs
+        if (this.show && popup.offsetWidth === 0) {
+          setTimeout(() => this.updatePosition(), 0)
+          return
+        }
+        const target = utils.isString(this.target)
+          ? this.$refs[this.target]
+          : this.target
+        if (target) {
+          const el = target === popup ? trigger : popup.firstChild
+          el.style.width = getComputedStyle(target).width
+        }
+        const bounds = (target || trigger).getBoundingClientRect()
+        const triggerLeft = bounds.left + window.scrollX
+        const triggerTop = bounds.top + window.scrollY
+        const triggerWidth = bounds.width
+        const triggerHeight = bounds.height
+        const popupWidth = popup.offsetWidth
+        const popupHeight = popup.offsetHeight
+        let [part1, part2] = this.popupPlacement.split('-') || []
+        if (this.keepInView) {
+          const winWidth = window.innerWidth
+          const winHeight = window.innerHeight
+          if (part1 === 'top') {
+            if (triggerTop < popupHeight) {
+              part1 = 'bottom'
+            }
+          } else if (part1 === 'bottom') {
+            if (winHeight - triggerTop - triggerHeight < popupHeight) {
+              part1 = 'top'
+            }
+          } else if (part1 === 'left') {
+            if (triggerLeft < popupWidth) {
+              part1 = 'right'
+            }
+          } else if (part1 === 'right') {
+            if (winWidth - triggerLeft - triggerWidth < popupWidth) {
+              part1 = 'left'
+            }
+          }
+          if (part2 === 'top') {
+            if (winHeight - triggerTop < popupHeight) {
+              part2 = 'bottom'
+            }
+          } else if (part2 === 'bottom') {
+            if (triggerTop + triggerHeight < popupHeight) {
+              part2 = 'top'
+            }
+          } else if (part2 === 'left') {
+            if (winWidth - triggerLeft < popupWidth) {
+              part2 = 'right'
+            }
+          } else if (part2 === 'right') {
+            if (triggerLeft + triggerWidth < popupWidth) {
+              part2 = 'left'
+            }
+          }
+        }
+        let left = 0
+        let top = 0
+        switch (part1) {
+          case 'top':
+            top -= popupHeight
+            break
+          case 'left':
+            left -= popupWidth
+            break
+          case 'right':
+            left += triggerWidth
+            break
+          case 'bottom':
+            top += triggerHeight
+            break
+        }
+        switch (part2) {
+          case 'right':
+            left -= popupWidth - triggerWidth
+            break
+          case 'bottom':
+            top -= popupHeight - triggerHeight
+            break
+        }
+        if (this.cover) {
+          if (part1 === 'top') {
+            top += triggerHeight
+          } else if (part1 === 'bottom') {
+            top -= triggerHeight
+          }
+        }
+        if (target && target !== trigger) {
+          const triggerBounds = trigger.getBoundingClientRect()
+          left += triggerLeft - triggerBounds.left
+          top += triggerTop - triggerBounds.top
+        }
+        popup.style.left = `${left}px`
+        popup.style.top = `${top}px`
+        this.$emit('update-position', {
+          trigger,
+          popup,
+          placement: this.popupPlacement
+        })
+      },
+      onClick() {
+        if (!this.disabled) {
+          this.showPopup = !this.showPopup
+        }
+      },
+      onHover(enter) {
+        if (!this.disabled) {
+          clearTimeout(this.mouseLeaveTimer)
+          if (enter) {
+            this.showPopup = true
+          } else {
+            if (this.hideDelay) {
+              this.mouseLeaveTimer = setTimeout(() => {
+                this.showPopup = false
+              }, this.hideDelay)
+            } else {
+              this.showPopup = false
+            }
+          }
+        }
+      }
+    }
+  }
+  const __cssModules$8 = {}
+  const __component__$8 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$8,
+    render$7,
+    staticRenderFns$7,
+    false,
+    __vue2_injectStyles$8,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$8(context) {
+    for (const o in __cssModules$8) {
+      this[o] = __cssModules$8[o]
+    }
+  }
+  __component__$8.options.__file = 'src/components/Trigger.vue'
+  const Trigger = /* @__PURE__ */ (function () {
+    return __component__$8.exports
+  })()
+  const render$6 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c(
+      'div',
+      {
+        staticClass: 'dito-input'
+      },
+      [
+        _vm.attributes.type === 'checkbox'
+          ? _c(
+              'input',
+              _vm._g(
+                _vm._b(
+                  {
+                    directives: [
+                      {
+                        name: 'model',
+                        rawName: 'v-model',
+                        value: _vm.currentValue,
+                        expression: 'currentValue'
+                      }
+                    ],
+                    ref: 'input',
+                    attrs: {
+                      'aria-label': _vm.title,
+                      'type': 'checkbox'
+                    },
+                    domProps: {
+                      checked: Array.isArray(_vm.currentValue)
+                        ? _vm._i(_vm.currentValue, null) > -1
+                        : _vm.currentValue
+                    },
+                    on: {
+                      change: function ($event) {
+                        const $$a = _vm.currentValue
+                        const $$el = $event.target
+                        const $$c = !!$$el.checked
+                        if (Array.isArray($$a)) {
+                          const $$v = null
+                          const $$i = _vm._i($$a, $$v)
+                          if ($$el.checked) {
+                            $$i < 0 && (_vm.currentValue = $$a.concat([$$v]))
+                          } else {
+                            $$i > -1 &&
+                            (_vm.currentValue = $$a
+                              .slice(0, $$i)
+                              .concat($$a.slice($$i + 1)))
+                          }
+                        } else {
+                          _vm.currentValue = $$c
+                        }
+                      }
+                    }
+                  },
+                  'input',
+                  _vm.attributes,
+                  false
+                ),
+                _vm.listeners
+              )
+            )
+          : _vm.attributes.type === 'radio'
+            ? _c(
+                'input',
+                _vm._g(
+                  _vm._b(
+                    {
+                      directives: [
+                        {
+                          name: 'model',
+                          rawName: 'v-model',
+                          value: _vm.currentValue,
+                          expression: 'currentValue'
+                        }
+                      ],
+                      ref: 'input',
+                      attrs: {
+                        'aria-label': _vm.title,
+                        'type': 'radio'
+                      },
+                      domProps: {
+                        checked: _vm._q(_vm.currentValue, null)
+                      },
+                      on: {
+                        change: function ($event) {
+                          _vm.currentValue = null
+                        }
+                      }
+                    },
+                    'input',
+                    _vm.attributes,
+                    false
+                  ),
+                  _vm.listeners
+                )
+              )
+            : _c(
+                'input',
+                _vm._g(
+                  _vm._b(
+                    {
+                      directives: [
+                        {
+                          name: 'model',
+                          rawName: 'v-model',
+                          value: _vm.currentValue,
+                          expression: 'currentValue'
+                        }
+                      ],
+                      ref: 'input',
+                      attrs: {
+                        'aria-label': _vm.title,
+                        'type': _vm.attributes.type
+                      },
+                      domProps: {
+                        value: _vm.currentValue
+                      },
+                      on: {
+                        input: function ($event) {
+                          if ($event.target.composing) {
+                            return
+                          }
+                          _vm.currentValue = $event.target.value
+                        }
+                      }
+                    },
+                    'input',
+                    _vm.attributes,
+                    false
+                  ),
+                  _vm.listeners
+                )
+              )
+      ]
+    )
+  }
+  const staticRenderFns$6 = []
+  render$6._withStripped = true
+  const InputField_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$7 = {
+    props: {
+      type: { type: String, default: 'text' },
+      value: { type: [String, Number], default: null },
+      id: { type: String, default: null },
+      name: { type: String, default: null },
+      title: { type: String, default: null },
+      disabled: { type: Boolean, default: false },
+      readonly: { type: Boolean, default: false },
+      placeholder: { type: String, default: null },
+      autocomplete: { type: String, default: 'off' }
+    },
+    data() {
+      return {
+        currentValue: this.value,
+        hovering: false,
+        focused: false
+      }
+    },
+    computed: {
+      attributes() {
+        const {
+          id,
+          name,
+          type,
+          size,
+          title,
+          disabled,
+          readonly,
+          placeholder,
+          autocomplete,
+          $attrs
+        } = this
+        return {
+          id,
+          name,
+          type,
+          size,
+          title,
+          disabled,
+          readonly,
+          placeholder,
+          autocomplete,
+          ...$attrs
+        }
+      },
+      listeners() {
+        const { input, ...listeners } = this.$listeners
+        return listeners
+      },
+      size() {
+        const { size, min, max } = this.$attrs
+        const getLength = value => (value != null ? `${value}`.length : 0)
+        return size || getLength(min) || getLength(max) || void 0
+      }
+    },
+    watch: {
+      value(newVal, oldVal) {
+        if (newVal !== oldVal) {
+          this.currentValue = newVal
+        }
+      },
+      currentValue(newVal) {
+        if (newVal !== this.value) {
+          this.$emit('input', newVal)
+        }
+      }
+    },
+    methods: {
+      focus() {
+        this.$refs.input.focus()
+      },
+      blur() {
+        this.$refs.input.blur()
+      }
+    }
+  }
+  const __cssModules$7 = {}
+  const __component__$7 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$7,
+    render$6,
+    staticRenderFns$6,
+    false,
+    __vue2_injectStyles$7,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$7(context) {
+    for (const o in __cssModules$7) {
+      this[o] = __cssModules$7[o]
+    }
+  }
+  __component__$7.options.__file = 'src/components/InputField.vue'
+  const InputField = /* @__PURE__ */ (function () {
+    return __component__$7.exports
+  })()
+  const render$5 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c(
+      'trigger',
+      _vm._b(
+        {
+          ref: 'trigger',
+          staticClass: 'dito-date-picker',
+          attrs: {
+            trigger: 'click',
+            show: _vm.showPopup
+          },
+          on: {
+            'update:show': function ($event) {
+              _vm.showPopup = $event
+            }
+          }
+        },
+        'trigger',
+        {
+          transition: _vm.transition,
+          placement: _vm.placement,
+          disabled: _vm.disabled,
+          target: _vm.target
+        },
+        false
+      ),
+      [
+        _c(
+          'input-field',
+          _vm._b(
+            {
+              ref: 'input',
+              staticClass: 'dito-date-picker-input',
+              class: {
+                'dito-focus': _vm.showPopup
+              },
+              attrs: {
+                slot: 'trigger',
+                type: 'text',
+                value: _vm.currentText,
+                readonly: ''
+              },
+              on: {
+                focus: function ($event) {
+                  _vm.inputFocused = true
+                },
+                blur: function ($event) {
+                  _vm.inputFocused = false
+                },
+                keydown: _vm.onKeyDown
+              },
+              slot: 'trigger'
+            },
+            'input-field',
+            {
+              placeholder: _vm.placeholder,
+              disabled: _vm.disabled
+            },
+            false
+          )
+        ),
+        _c(
+          'calendar',
+          _vm._b(
+            {
+              ref: 'calendar',
+              staticClass: 'dito-date-picker-popup',
+              attrs: {
+                slot: 'popup',
+                value: _vm.currentValue
+              },
+              on: {
+                input: _vm.selectDate
+              },
+              slot: 'popup'
+            },
+            'calendar',
+            {
+              locale: _vm.locale,
+              disabledDate: _vm.disabledDate
+            },
+            false
+          )
+        )
+      ],
+      1
+    )
+  }
+  const staticRenderFns$5 = []
+  render$5._withStripped = true
+  const DatePicker_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$6 = {
+    components: { Trigger, Calendar, InputField },
+    props: {
+      value: { type: Date, default: null },
+      transition: { type: String, default: 'slide' },
+      placement: { type: String, default: 'bottom-left' },
+      placeholder: { type: String, default: null },
+      locale: { type: String, default: 'en-US' },
+      dateFormat: { type: Object, default: () => utils.defaultFormats.date },
+      show: { type: Boolean, default: false },
+      disabled: { type: Boolean, default: false },
+      target: { type: [String, HTMLElement], default: 'trigger' },
+      disabledDate: { type: Function, default: () => false }
+    },
+    data() {
+      return {
+        currentValue: this.value,
+        showPopup: this.show,
+        inputFocused: false,
+        changed: false
+      }
+    },
+    computed: {
+      focused() {
+        return this.inputFocused || this.showPopup
+      },
+      currentText() {
+        return (
+          utils.format(this.currentValue, {
+            locale: this.locale,
+            date: this.dateFormat,
+            time: false
+          }) || ''
+        )
+      }
+    },
+    watch: {
+      value(newVal, oldVal) {
+        if (+newVal !== +oldVal) {
+          this.currentValue = newVal
+        }
+      },
+      currentValue(date) {
+        if (+date !== +this.value) {
+          this.changed = true
+          this.$emit('input', date)
+        }
+      },
+      show(show) {
+        this.showPopup = show
+      },
+      showPopup(newVal, oldVal) {
+        if (!newVal !== !oldVal) {
+          this.$emit('update:show', newVal)
+        }
+      },
+      focused(newVal, oldVal) {
+        if (!newVal !== !oldVal) {
+          this.$emit(newVal ? 'focus' : 'blur')
+        }
+      }
+    },
+    mounted() {
+      this.$on('blur', () => {
+        if (this.changed) {
+          this.changed = false
+          this.$emit('change', this.currentValue)
+        }
+      })
+    },
+    methods: {
+      selectDate(date) {
+        this.currentValue = date
+        this.showPopup = false
+      },
+      onKeyDown(event) {
+        let _a
+        if (
+          (_a = this.$refs.calendar) == null
+            ? void 0
+            : _a.navigate(getKeyNavigation(event))
+        ) {
+          event.preventDefault()
+        }
+      },
+      focus() {
+        this.$refs.input.focus()
+      },
+      blur() {
+        this.$refs.input.blur()
+      }
+    }
+  }
+  const __cssModules$6 = {}
+  const __component__$6 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$6,
+    render$5,
+    staticRenderFns$5,
+    false,
+    __vue2_injectStyles$6,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$6(context) {
+    for (const o in __cssModules$6) {
+      this[o] = __cssModules$6[o]
+    }
+  }
+  __component__$6.options.__file = 'src/components/DatePicker.vue'
+  const DatePicker = /* @__PURE__ */ (function () {
+    return __component__$6.exports
+  })()
+  const render$4 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c(
+      'trigger',
+      _vm._b(
+        {
+          ref: 'trigger',
+          staticClass: 'dito-time-picker',
+          attrs: {
+            trigger: 'click',
+            show: _vm.showPopup
+          },
+          on: {
+            'update:show': function ($event) {
+              _vm.showPopup = $event
+            }
+          }
+        },
+        'trigger',
+        {
+          transition: _vm.transition,
+          placement: _vm.placement,
+          disabled: _vm.disabled,
+          target: _vm.target
+        },
+        false
+      ),
+      [
+        _c(
+          'input-field',
+          _vm._b(
+            {
+              ref: 'input',
+              staticClass: 'dito-time-picker-input',
+              class: {
+                'dito-focus': _vm.showPopup
+              },
+              attrs: {
+                slot: 'trigger',
+                type: 'text',
+                value: _vm.currentText,
+                readonly: ''
+              },
+              on: {
+                focus: function ($event) {
+                  _vm.inputFocused = true
+                },
+                blur: function ($event) {
+                  _vm.inputFocused = false
+                },
+                keydown: _vm.onKeyDown
+              },
+              slot: 'trigger'
+            },
+            'input-field',
+            {
+              placeholder: _vm.placeholder,
+              disabled: _vm.disabled
+            },
+            false
+          )
+        ),
+        _c(
+          'div',
+          {
+            staticClass: 'dito-time-picker-popup',
+            attrs: {
+              slot: 'popup'
+            },
+            slot: 'popup'
+          },
+          [
+            _c(
+              'div',
+              {
+                staticClass: 'dito-time-picker-panel'
+              },
+              [
+                _c(
+                  'ul',
+                  {
+                    ref: 'hour',
+                    staticClass: 'dito-time-picker-hour',
+                    on: {
+                      mouseover: function ($event) {
+                        _vm.selection = 0
+                      }
+                    }
+                  },
+                  _vm._l(24, function (index2) {
+                    return !_vm.disabledHour(index2 - 1)
+                      ? _c(
+                          'li',
+                          {
+                            class: {
+                              selected: _vm.hour === index2 - 1
+                            },
+                            on: {
+                              click: function ($event) {
+                                _vm.hour = index2 - 1
+                              }
+                            }
+                          },
+                          [_vm._v(_vm._s(_vm.leftPad(index2 - 1)))]
+                        )
+                      : _vm._e()
+                  }),
+                  0
+                )
+              ]
+            ),
+            _c(
+              'div',
+              {
+                staticClass: 'dito-time-picker-panel'
+              },
+              [
+                _c(
+                  'ul',
+                  {
+                    ref: 'minute',
+                    staticClass: 'dito-time-picker-minute',
+                    on: {
+                      mouseover: function ($event) {
+                        _vm.selection = 1
+                      }
+                    }
+                  },
+                  _vm._l(60, function (index2) {
+                    return !_vm.disabledMinute(index2 - 1)
+                      ? _c(
+                          'li',
+                          {
+                            class: {
+                              selected: _vm.minute === index2 - 1
+                            },
+                            on: {
+                              click: function ($event) {
+                                _vm.minute = index2 - 1
+                              }
+                            }
+                          },
+                          [_vm._v(_vm._s(_vm.leftPad(index2 - 1)))]
+                        )
+                      : _vm._e()
+                  }),
+                  0
+                )
+              ]
+            ),
+            _c(
+              'div',
+              {
+                staticClass: 'dito-time-picker-panel'
+              },
+              [
+                _c(
+                  'ul',
+                  {
+                    ref: 'second',
+                    staticClass: 'dito-time-picker-second',
+                    on: {
+                      mouseover: function ($event) {
+                        _vm.selection = 2
+                      }
+                    }
+                  },
+                  _vm._l(60, function (index2) {
+                    return !_vm.disabledSecond(index2 - 1)
+                      ? _c(
+                          'li',
+                          {
+                            class: {
+                              selected: _vm.second === index2 - 1
+                            },
+                            on: {
+                              click: function ($event) {
+                                _vm.second = index2 - 1
+                              }
+                            }
+                          },
+                          [_vm._v(_vm._s(_vm.leftPad(index2 - 1)))]
+                        )
+                      : _vm._e()
+                  }),
+                  0
+                )
+              ]
+            )
+          ]
+        )
+      ],
+      1
+    )
+  }
+  const staticRenderFns$4 = []
+  render$4._withStripped = true
+  const TimePicker_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$5 = {
+    components: { Trigger, InputField },
+    props: {
+      value: { type: Date, default: null },
+      transition: { type: String, default: 'slide' },
+      placement: { type: String, default: 'bottom-left' },
+      placeholder: { type: String, default: null },
+      show: { type: Boolean, default: false },
+      disabled: { type: Boolean, default: false },
+      target: { type: [String, HTMLElement], default: 'trigger' },
+      disabledHour: { type: Function, default: () => false },
+      disabledMinute: { type: Function, default: () => false },
+      disabledSecond: { type: Function, default: () => false }
+    },
+    data() {
+      return {
+        currentValue: this.value,
+        showPopup: this.show,
+        inputFocused: false,
+        selection: 0,
+        changed: false
+      }
+    },
+    computed: {
+      focused() {
+        return this.inputFocused || this.showPopup
+      },
+      currentText() {
+        return this.currentValue
+          ? `${this.leftPad(this.hour)}:${this.leftPad(this.minute)}:${
+              this.leftPad(this.second)
+            }`
+          : ''
+      },
+      currentDate() {
+        return (
+          this.currentValue ||
+          copyDate(new Date(), { hour: 0, minute: 0, second: 0 })
+        )
+      },
+      hour: {
+        get() {
+          return this.currentDate.getHours()
+        },
+        set(hour) {
+          this.setTime({ hour })
+        }
+      },
+      minute: {
+        get() {
+          return this.currentDate.getMinutes()
+        },
+        set(minute) {
+          this.setTime({ minute })
+        }
+      },
+      second: {
+        get() {
+          return this.currentDate.getSeconds()
+        },
+        set(second) {
+          this.setTime({ second })
+        }
+      }
+    },
+    watch: {
+      value(newVal, oldVal) {
+        if (+newVal !== +oldVal) {
+          this.currentValue = newVal
+        }
+      },
+      currentValue(date) {
+        if (+date !== +this.value) {
+          this.changed = true
+          this.$emit('input', date)
+          this.scrollAll()
+        }
+      },
+      currentText: 'updateSelection',
+      selection: 'updateSelection',
+      show(show) {
+        this.showPopup = show
+      },
+      showPopup(newVal, oldVal) {
+        if (newVal) {
+          this.updateSelection()
+          this.scrollAll(0)
+        }
+        if (!newVal !== !oldVal) {
+          this.$emit('update:show', newVal)
+        }
+      },
+      focused(newVal, oldVal) {
+        if (!newVal !== !oldVal) {
+          this.$emit(newVal ? 'focus' : 'blur')
+        }
+      }
+    },
+    mounted() {
+      this.$on('blur', () => {
+        if (this.changed) {
+          this.changed = false
+          this.$emit('change', this.currentValue)
+        }
+      })
+    },
+    methods: {
+      leftPad(value) {
+        return ('0' + value).slice(-2)
+      },
+      setTime(param) {
+        this.currentValue = copyDate(this.currentDate, param)
+      },
+      updateSelection(force = false) {
+        if (this.showPopup || force) {
+          const start = 3 * this.selection
+          this.$nextTick(() => setSelection(this.$refs.input, start, start + 2))
+        }
+      },
+      scrollAll(duration = 100) {
+        const scroll = (ref, value) => {
+          const target = this.$refs[ref]
+          if (target) {
+            const lineHeight = (
+              target.scrollHeight /
+              (target.children.length + 6)
+            )
+            scrollTo(target, Math.round(value * lineHeight), duration)
+          }
+        }
+        this.$nextTick(() => {
+          scroll('hour', this.hour)
+          scroll('minute', this.minute)
+          scroll('second', this.second)
+        })
+      },
+      onKeyDown(event) {
+        const selected = ['hour', 'minute', 'second'][this.selection]
+        if (selected) {
+          const { hor, ver, enter } = getKeyNavigation(event)
+          if (hor) {
+            const value = this.selection + hor
+            this.selection = value < 0 ? 2 : value > 2 ? 0 : value
+          } else if (ver) {
+            const value = this[selected] + ver
+            const { length } = this.$refs[selected].children
+            this[selected] =
+              value < 0
+                ? value + length
+                : value >= length
+                  ? value - length
+                  : value
+          }
+          if (enter) {
+            this.showPopup = false
+          }
+          if (hor || ver || enter) {
+            this.updateSelection(true)
+            event.preventDefault()
+          }
+        }
+      },
+      focus() {
+        this.$refs.input.focus()
+      },
+      blur() {
+        this.$refs.input.blur()
+      }
+    }
+  }
+  const __cssModules$5 = {}
+  const __component__$5 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$5,
+    render$4,
+    staticRenderFns$4,
+    false,
+    __vue2_injectStyles$5,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$5(context) {
+    for (const o in __cssModules$5) {
+      this[o] = __cssModules$5[o]
+    }
+  }
+  __component__$5.options.__file = 'src/components/TimePicker.vue'
+  const TimePicker = /* @__PURE__ */ (function () {
+    return __component__$5.exports
+  })()
+  const render$3 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c(
+      'div',
+      {
+        ref: 'picker',
+        staticClass: 'dito-date-time-picker'
+      },
+      [
+        _c(
+          'div',
+          {
+            staticClass: 'dito-pickers',
+            class: {
+              'dito-focus': _vm.focused
+            }
+          },
+          [
+            _c(
+              'date-picker',
+              _vm._b(
+                {
+                  ref: 'date',
+                  attrs: {
+                    placement: 'bottom-left',
+                    target: _vm.$refs.picker,
+                    show: _vm.showDate
+                  },
+                  on: {
+                    'update:show': function ($event) {
+                      _vm.showDate = $event
+                    },
+                    'focus': function ($event) {
+                      _vm.dateFocused = true
+                    },
+                    'blur': function ($event) {
+                      _vm.dateFocused = false
+                    }
+                  },
+                  model: {
+                    value: _vm.currentValue,
+                    callback: function ($$v) {
+                      _vm.currentValue = $$v
+                    },
+                    expression: 'currentValue'
+                  }
+                },
+                'date-picker',
+                {
+                  transition: _vm.transition,
+                  placeholder: _vm.placeholder,
+                  locale: _vm.locale,
+                  dateFormat: _vm.dateFormat,
+                  disabled: _vm.disabled
+                },
+                false
+              )
+            ),
+            _c(
+              'time-picker',
+              _vm._b(
+                {
+                  ref: 'time',
+                  attrs: {
+                    placeholder: '',
+                    placement: 'bottom-right',
+                    target: _vm.$refs.picker,
+                    show: _vm.showTime
+                  },
+                  on: {
+                    'update:show': function ($event) {
+                      _vm.showTime = $event
+                    },
+                    'focus': function ($event) {
+                      _vm.timeFocused = true
+                    },
+                    'blur': function ($event) {
+                      _vm.timeFocused = false
+                    }
+                  },
+                  model: {
+                    value: _vm.currentValue,
+                    callback: function ($$v) {
+                      _vm.currentValue = $$v
+                    },
+                    expression: 'currentValue'
+                  }
+                },
+                'time-picker',
+                {
+                  transition: _vm.transition,
+                  disabled: _vm.disabled
+                },
+                false
+              )
+            )
+          ],
+          1
+        )
+      ]
+    )
+  }
+  const staticRenderFns$3 = []
+  render$3._withStripped = true
+  const DateTimePicker_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$4 = {
+    components: { DatePicker, TimePicker },
+    props: {
+      value: { type: Date, default: null },
+      transition: { type: String, default: 'slide' },
+      placeholder: { type: String, default: null },
+      dateFormat: { type: Object, default: () => utils.defaultFormats.date },
+      locale: { type: String, default: 'en-US' },
+      disabled: { type: Boolean, default: false }
+    },
+    data() {
+      return {
+        currentValue: this.value,
+        showDate: false,
+        showTime: false,
+        dateFocused: false,
+        timeFocused: false,
+        changed: false
+      }
+    },
+    computed: {
+      focused() {
+        return this.dateFocused || this.timeFocused
+      }
+    },
+    watch: {
+      value(newVal, oldVal) {
+        if (+newVal !== +oldVal) {
+          this.currentValue = newVal
+        }
+      },
+      currentValue(date) {
+        if (+date !== +this.value) {
+          this.changed = true
+          this.$emit('input', date)
+        }
+      },
+      focused(newVal, oldVal) {
+        if (!newVal !== !oldVal) {
+          this.$emit(newVal ? 'focus' : 'blur')
+        }
+      }
+    },
+    mounted() {
+      this.$on('blur', () => {
+        if (this.changed) {
+          this.changed = false
+          this.$emit('change', this.currentValue)
+        }
+      })
+    },
+    methods: {
+      focus() {
+        this.$refs.date.focus()
+      },
+      blur() {
+        this.$refs.date.blur()
+        this.$refs.time.blur()
+      }
+    }
+  }
+  const __cssModules$4 = {}
+  const __component__$4 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$4,
+    render$3,
+    staticRenderFns$3,
+    false,
+    __vue2_injectStyles$4,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$4(context) {
+    for (const o in __cssModules$4) {
+      this[o] = __cssModules$4[o]
+    }
+  }
+  __component__$4.options.__file = 'src/components/DateTimePicker.vue'
+  const DateTimePicker = /* @__PURE__ */ (function () {
+    return __component__$4.exports
+  })()
+  const render$2 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c('i', {
+      staticClass: 'dito-icon',
+      class: `dito-icon-${_vm.name}`
+    })
+  }
+  const staticRenderFns$2 = []
+  render$2._withStripped = true
+  const Icon_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$3 = {
+    props: {
+      name: {
+        type: String,
+        required: true
+      }
+    }
+  }
+  const __cssModules$3 = {}
+  const __component__$3 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$3,
+    render$2,
+    staticRenderFns$2,
+    false,
+    __vue2_injectStyles$3,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$3(context) {
+    for (const o in __cssModules$3) {
+      this[o] = __cssModules$3[o]
+    }
+  }
+  __component__$3.options.__file = 'src/components/Icon.vue'
+  const Icon = /* @__PURE__ */ (function () {
+    return __component__$3.exports
+  })()
+  const render$1 = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _vm.numPages > 1
+      ? _c(
+          'div',
+          {
+            staticClass: 'dito-pagination'
+          },
+          [
+            _vm.showTotal
+              ? _c(
+                  'div',
+                  {
+                    staticClass: 'dito-pagination-total'
+                  },
+                  [
+                    _vm.total > 0
+                      ? [
+                          _vm._v(
+                            _vm._s(_vm.first) + ' \u2013 ' + _vm._s(_vm.last)
+                          )
+                        ]
+                      : [_vm._v('0')],
+                    _vm._v(' / ' + _vm._s(_vm.total))
+                  ],
+                  2
+                )
+              : _vm._e(),
+            _c(
+              'div',
+              {
+                staticClass: 'dito-buttons dito-buttons-round'
+              },
+              _vm._l(_vm.pageRange, function (page) {
+                return _c(
+                  'button',
+                  {
+                    staticClass: 'dito-button',
+                    class: _vm.getPageClass(page),
+                    attrs: {
+                      disabled: page.disabled
+                    },
+                    on: {
+                      click: function ($event) {
+                        return _vm.onClickPage(page)
+                      }
+                    }
+                  },
+                  [
+                    page.text
+                      ? _c('span', [_vm._v(_vm._s(page.text))])
+                      : _vm._e()
+                  ]
+                )
+              }),
+              0
+            )
+          ]
+        )
+      : _vm._e()
+  }
+  const staticRenderFns$1 = []
+  render$1._withStripped = true
+  const Pagination_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$2 = {
+    props: {
+      total: { type: Number, default: 0 },
+      page: { type: Number, default: 1 },
+      pageSize: { type: Number, default: 10 },
+      showTotal: { type: Boolean, default: true }
+    },
+    data() {
+      return {
+        pageRange: [],
+        showPrev: true,
+        showNext: true,
+        numPages: 0,
+        currentPageSize: this.pageSize,
+        currentPage: this.page
+      }
+    },
+    computed: {
+      first() {
+        return (this.currentPage - 1) * this.currentPageSize + 1
+      },
+      last() {
+        return Math.min(this.first + this.currentPageSize - 1, this.total)
+      }
+    },
+    watch: {
+      total: 'updatePageRange',
+      showPrev: 'updatePageRange',
+      showNext: 'updatePageRange',
+      page(page) {
+        this.currentPage = page
+      },
+      pageSize(pageSize) {
+        this.currentPageSize = pageSize
+      },
+      currentPageSize(currentPageSize) {
+        this.numPages = Math.ceil(this.total / currentPageSize)
+        if (this.currentPage > this.numPages) {
+          this.currentPage = this.numPages
+        }
+        this.updatePageRange()
+        this.$emit('size-change', this.page, currentPageSize)
+      },
+      currentPage(newVal, oldVal) {
+        if (newVal !== oldVal) {
+          this.updatePageRange()
+          this.$emit('update:page', newVal)
+        }
+      }
+    },
+    created() {
+      this.currentPage = this.page
+      this.currentPageSize = this.pageSize
+    },
+    mounted() {
+      this.updatePageRange()
+    },
+    methods: {
+      onClickPage(page) {
+        if (page.index && !page.disabled && page.index !== this.currentPage) {
+          this.currentPage = page.index
+        }
+      },
+      getPageClass(page) {
+        const classes = {
+          'dito-selected': page.active
+        }
+        if (page.type) {
+          classes[`dito-button-${page.type}`] = true
+        }
+        return classes
+      },
+      updatePageRange() {
+        const { showPrev, showNext, total, currentPageSize, currentPage } = this
+        const showLength = showPrev + showNext + 1
+        const numPages = (this.numPages = Math.ceil(total / currentPageSize))
+        let start = 1
+        let end = 1
+        if (numPages <= showLength) {
+          end = numPages
+        } else if (currentPage <= showPrev + 1) {
+          end = showLength
+        } else if (currentPage >= numPages - showNext) {
+          end = numPages
+          start = numPages - showLength + 1
+        } else {
+          start = currentPage - showPrev
+          end = currentPage + showNext
+        }
+        const pageRange = []
+        pageRange.push({
+          index: currentPage - 1,
+          type: 'prev',
+          disabled: currentPage <= 1
+        })
+        if (start >= 2) {
+          pageRange.push({ index: 1, text: 1 })
+        }
+        if (start > 2) {
+          pageRange.push({
+            index: Math.max(1, currentPage - 10),
+            type: 'ellipsis-prev'
+          })
+        }
+        for (let i = start; i <= end; i++) {
+          pageRange.push({
+            index: i,
+            text: i,
+            active: i === currentPage
+          })
+        }
+        if (end < numPages - 1) {
+          pageRange.push({
+            index: Math.min(numPages, currentPage + 10),
+            type: 'ellipsis-next'
+          })
+        }
+        if (end <= numPages - 1) {
+          pageRange.push({ index: numPages, text: numPages })
+        }
+        pageRange.push({
+          index: currentPage + 1,
+          type: 'next',
+          disabled: currentPage >= numPages
+        })
+        this.pageRange = pageRange
+      }
+    }
+  }
+  const __cssModules$2 = {}
+  const __component__$2 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$2,
+    render$1,
+    staticRenderFns$1,
+    false,
+    __vue2_injectStyles$2,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$2(context) {
+    for (const o in __cssModules$2) {
+      this[o] = __cssModules$2[o]
+    }
+  }
+  __component__$2.options.__file = 'src/components/Pagination.vue'
+  const Pagination = /* @__PURE__ */ (function () {
+    return __component__$2.exports
+  })()
+  const render = function () {
+    const _vm = this
+    const _h = _vm.$createElement
+    const _c = _vm._self._c || _h
+    return _c(
+      'div',
+      {
+        staticClass: 'dito-switch',
+        class: _vm.classes,
+        style: _vm.styles
+      },
+      [
+        _c(
+          'div',
+          {
+            staticClass: 'dito-switch-pane'
+          },
+          [
+            _c(
+              'input',
+              _vm._b(
+                {
+                  directives: [
+                    {
+                      name: 'model',
+                      rawName: 'v-model',
+                      value: _vm.checked,
+                      expression: 'checked'
+                    }
+                  ],
+                  ref: 'input',
+                  attrs: {
+                    type: 'checkbox'
+                  },
+                  domProps: {
+                    checked: Array.isArray(_vm.checked)
+                      ? _vm._i(_vm.checked, null) > -1
+                      : _vm.checked
+                  },
+                  on: {
+                    change: function ($event) {
+                      const $$a = _vm.checked
+                      const $$el = $event.target
+                      const $$c = !!$$el.checked
+                      if (Array.isArray($$a)) {
+                        const $$v = null
+                        const $$i = _vm._i($$a, $$v)
+                        if ($$el.checked) {
+                          $$i < 0 && (_vm.checked = $$a.concat([$$v]))
+                        } else {
+                          $$i > -1 &&
+                          (_vm.checked = $$a
+                            .slice(0, $$i)
+                            .concat($$a.slice($$i + 1)))
+                        }
+                      } else {
+                        _vm.checked = $$c
+                      }
+                    }
+                  }
+                },
+                'input',
+                _vm.attributes,
+                false
+              )
+            ),
+            _c('div', {
+              staticClass: 'dito-switch-button'
+            }),
+            _vm.labels
+              ? _c(
+                  'span',
+                  {
+                    staticClass: 'dito-switch-label'
+                  },
+                  [
+                    _vm.checked
+                      ? _vm._t('checked', function () {
+                          return [_vm._v(_vm._s(_vm.labels.checked || 'on'))]
+                        })
+                      : _vm._t('unchecked', function () {
+                          return [_vm._v(_vm._s(_vm.labels.unchecked || 'off'))]
+                        })
+                  ],
+                  2
+                )
+              : _vm._e()
+          ]
+        )
+      ]
+    )
+  }
+  const staticRenderFns = []
+  render._withStripped = true
+  const SwitchButton_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script$1 = {
+    props: {
+      value: { type: Boolean, default: false },
+      id: { type: String, default: null },
+      name: { type: String, default: null },
+      disabled: { type: Boolean, default: false },
+      labels: { type: [Object, Boolean], default: false }
+    },
+    data() {
+      return {
+        checked: this.value
+      }
+    },
+    computed: {
+      classes() {
+        const { checked, disabled } = this
+        return {
+          'dito-checked': checked,
+          'dito-disabled': disabled
+        }
+      },
+      styles() {
+        const { labels: { checked, unchecked } = {} } = this
+        const length = Math.max(
+          0,
+          checked == null ? void 0 : checked.length,
+          unchecked == null ? void 0 : unchecked.length
+        )
+        return {
+          '--switch-width': length ? `${length * 1.5}rem` : null
+        }
+      },
+      attributes() {
+        const { id, name, disabled, $attrs } = this
+        return { id, name, disabled, ...$attrs }
+      }
+    },
+    watch: {
+      value(value) {
+        this.checked = value
+      },
+      checked(checked) {
+        if (checked !== this.value) {
+          this.$emit('input', checked)
+          this.$emit('change', checked)
+        }
+      }
+    },
+    methods: {
+      focus() {
+        this.$refs.input.focus()
+      }
+    }
+  }
+  const __cssModules$1 = {}
+  const __component__$1 = /* @__PURE__ */ normalizeComponent(
+    __vue2_script$1,
+    render,
+    staticRenderFns,
+    false,
+    __vue2_injectStyles$1,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles$1(context) {
+    for (const o in __cssModules$1) {
+      this[o] = __cssModules$1[o]
+    }
+  }
+  __component__$1.options.__file = 'src/components/SwitchButton.vue'
+  const SwitchButton = /* @__PURE__ */ (function () {
+    return __component__$1.exports
+  })()
+  const TransitionHeight_vue_vue_type_style_index_0_lang = ''
+  const __vue2_script = {
+    functional: true,
+    props: {
+      enabled: { type: Boolean, default: true }
+    },
+    render: (createElement, context) =>
+      createElement(
+        'transition',
+        context.props.enabled
+          ? {
+              props: { name: 'height' },
+              on: events
+            }
+          : {},
+        context.children
+      )
+  }
+  const setStyle = (element, style) => Object.assign(element.style, style)
+  const forceRepaint = element => getComputedStyle(element).height
+  const events = {
+    afterEnter(element) {
+      setTimeout(() => setStyle(element, { height: 'auto' }))
+    },
+    enter(element) {
+      const { width } = getComputedStyle(element)
+      setStyle(element, {
+        width,
+        position: 'absolute',
+        visibility: 'hidden',
+        height: 'auto'
+      })
+      const { height } = getComputedStyle(element)
+      setStyle(element, {
+        width: null,
+        position: null,
+        visibility: null,
+        height: 0
+      })
+      forceRepaint(element)
+      setTimeout(() => setStyle(element, { height }))
+    },
+    leave(element) {
+      const { height } = getComputedStyle(element)
+      setStyle(element, { height })
+      forceRepaint(element)
+      setTimeout(() => setStyle(element, { height: 0 }))
+    }
+  }
+  let __vue2_render, __vue2_staticRenderFns
+  const __cssModules = {}
+  const __component__ = /* @__PURE__ */ normalizeComponent(
+    __vue2_script,
+    __vue2_render,
+    __vue2_staticRenderFns,
+    false,
+    __vue2_injectStyles,
+    null,
+    null,
+    null
+  )
+  function __vue2_injectStyles(context) {
+    for (const o in __cssModules) {
+      this[o] = __cssModules[o]
+    }
+  }
+  __component__.options.__file = 'src/transitions/TransitionHeight.vue'
+  const TransitionHeight = /* @__PURE__ */ (function () {
+    return __component__.exports
+  })()
+  exports2.Calendar = Calendar
+  exports2.DatePicker = DatePicker
+  exports2.DateTimePicker = DateTimePicker
+  exports2.Icon = Icon
+  exports2.InputField = InputField
+  exports2.Pagination = Pagination
+  exports2.SwitchButton = SwitchButton
+  exports2.TimePicker = TimePicker
+  exports2.TransitionHeight = TransitionHeight
+  exports2.Trigger = Trigger
+  exports2.addEvents = addEvents
+  exports2.convertDate = convertDate
+  exports2.copyDate = copyDate
+  exports2.getAbsoluteBoundingRect = getAbsoluteBoundingRect
+  exports2.getKey = getKey
+  exports2.getKeyNavigation = getKeyNavigation
+  exports2.scrollTo = scrollTo
+  exports2.setSelection = setSelection
+  Object.defineProperties(exports2, {
+    __esModule: { value: true },
+    [Symbol.toStringTag]: { value: 'Module' }
+  })
+})
+// # sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dito-ui.umd.js","sources":["../src/utils/bounds.js","../src/utils/date.js","../src/utils/event.js","../src/utils/scroll.js","../src/utils/selection.js","../src/components/Calendar.vue?vue&type=template&lang.js","../src/components/Calendar.vue","../src/components/Trigger.vue?vue&type=template&lang.js","../src/components/Trigger.vue","../src/components/InputField.vue?vue&type=template&lang.js","../src/components/InputField.vue","../src/components/DatePicker.vue?vue&type=template&lang.js","../src/components/DatePicker.vue","../src/components/TimePicker.vue?vue&type=template&lang.js","../src/components/TimePicker.vue","../src/components/DateTimePicker.vue?vue&type=template&lang.js","../src/components/DateTimePicker.vue","../src/components/Icon.vue?vue&type=template&lang.js","../src/components/Icon.vue","../src/components/Pagination.vue?vue&type=template&lang.js","../src/components/Pagination.vue","../src/components/SwitchButton.vue?vue&type=template&lang.js","../src/components/SwitchButton.vue","../src/transitions/TransitionHeight.vue"],"sourcesContent":["export function getAbsoluteBoundingRect(el) {\n  const doc = document\n  const win = window\n  const body = doc.body\n  // pageXOffset and pageYOffset work everywhere except IE <9.\n  let offsetX = win.pageXOffset !== undefined ? win.pageXOffset\n    : (doc.documentElement || body.parentNode || body).scrollLeft\n  let offsetY = win.pageYOffset !== undefined ? win.pageYOffset\n    : (doc.documentElement || body.parentNode || body).scrollTop\n  const rect = el.getBoundingClientRect()\n  if (el !== body) {\n    let parent = el.parentNode\n    // The element's rect will be affected by the scroll positions of\n    // *all* of its scrollable parents, not just the window, so we have\n    // to walk up the tree and collect every scroll offset. Good times.\n    while (parent !== body) {\n      offsetX += parent.scrollLeft\n      offsetY += parent.scrollTop\n      parent = parent.parentNode\n    }\n  }\n  return {\n    bottom: rect.bottom + offsetY,\n    height: rect.height,\n    left: rect.left + offsetX,\n    right: rect.right + offsetX,\n    top: rect.top + offsetY,\n    width: rect.width\n  }\n}\n","import { isDate, pick } from '@ditojs/utils'\n\nexport function copyDate(date,\n  { year, month, day, hour, minute, second, millisecond } = {}\n) {\n  return new Date(\n    pick(year, date && date.getFullYear(), 0),\n    pick(month, date && date.getMonth(), 0),\n    pick(day, date && date.getDate(), 0),\n    pick(hour, date && date.getHours(), 0),\n    pick(minute, date && date.getMinutes(), 0),\n    pick(second, date && date.getSeconds(), 0),\n    pick(millisecond, date && date.getMilliseconds(), 0)\n  )\n}\n\nexport function convertDate(date) {\n  return isDate(date) ? date : date ? new Date(date) : null\n}\n","export function addEvents(target, events) {\n  for (const type in events) {\n    target.addEventListener(type, events[type], false)\n  }\n  return {\n    remove() {\n      for (const type in events) {\n        target.removeEventListener(type, events[type], false)\n      }\n    }\n  }\n}\n\nexport function getKey(event) {\n  return {\n    37: 'left',\n    38: 'up',\n    39: 'right',\n    40: 'down',\n    13: 'enter'\n  }[event.keyCode]\n}\n\nexport function getKeyNavigation(event) {\n  const key = getKey(event)\n  return {\n    hor: { left: -1, right: 1 }[key] || 0,\n    ver: { up: -1, down: 1 }[key] || 0,\n    enter: key === 'enter'\n  }\n}\n","export function scrollTo(element, to, duration) {\n  const requestAnimationFrame = window.requestAnimationFrame || function() {\n    return setTimeout(arguments[0], 10)\n  }\n  if (duration <= 0) {\n    element.scrollTop = to\n  } else {\n    const difference = to - element.scrollTop\n    const perTick = difference / duration * 10\n    requestAnimationFrame(() => {\n      element.scrollTop = element.scrollTop + perTick\n      if (element.scrollTop === to) return\n      scrollTo(element, to, duration - 10)\n    })\n  }\n}\n","export function setSelection(field, start, end) {\n  if (field.createTextRange) {\n    const range = field.createTextRange()\n    range.collapse(true)\n    range.moveStart('character', start)\n    range.moveEnd('character', end)\n    range.select()\n    field.focus()\n  } else if (field.setSelectionRange) {\n    field.focus()\n    field.setSelectionRange(start, end)\n  } else if ('selectionStart' in field) {\n    field.selectionStart = start\n    field.selectionEnd = end\n    field.focus()\n  }\n}\n","\n.dito-calendar\n  .dito-calendar-popup\n    .dito-calendar-inner\n      template(\n        v-if=\"currentMode === 'day'\"\n      )\n        .dito-calendar-header\n          a.dito-calendar-step-prev.dito-calendar-step-year(\n            @click=\"stepYear(-1)\"\n          )\n          a.dito-calendar-step-prev.dito-calendar-step-month(\n            @click=\"stepMonth(-1)\"\n          )\n          span\n            a.dito-calendar-select-year(\n              @click=\"setMode('year')\"\n            ) {{ dateToString(currentValue, { year: 1 }) }}\n            a.dito-calendar-select-month(\n              @click=\"setMode('month')\"\n            ) {{ dateToString(currentValue, { month: 1 }) }}\n          a.dito-calendar-step-next.dito-calendar-step-month(\n            @click=\"stepMonth(1)\"\n          )\n          a.dito-calendar-step-next.dito-calendar-step-year(\n            @click=\"stepYear(1)\"\n          )\n        .dito-calendar-body\n          .dito-calendar-weekdays\n            span(\n              v-for=\"weekday in weekdayNames\"\n            ) {{ weekday.short }}\n          .dito-calendar-dates\n            span(\n              v-for=\"date in dateRange\"\n              :class=\"date.state && `dito-calendar-item-${date.state}`\"\n              @click=\"selectDate(date.date, date.state, true)\"\n            ) {{ date.text }}\n        .dito-calendar-footer\n          a.dito-calendar-select-today(\n            role=\"button\"\n            @click=\"selectDate(new Date())\"\n            :title=\"dateToString(new Date(), { year: 1, month: 1, day: 1 })\"\n          )\n      template(\n        v-else-if=\"currentMode === 'month'\"\n      )\n        .dito-calendar-header\n          a.dito-calendar-step-prev(\n            @click=\"stepYear(-1)\"\n          )\n          span\n            a.dito-calendar-select-year(\n              @click=\"setMode('year')\"\n            ) {{ dateToString(currentValue, { year: 1 }) }}\n          a.dito-calendar-step-next(\n            @click=\"stepYear(1)\"\n          )\n        .dito-calendar-body\n          .dito-calendar-months\n            span(\n              v-for=\"(month, index) in monthNames\"\n              :class=\"getMonthClass(index)\"\n              @click=\"selectMonth(index)\"\n            ) {{ month.short }}\n      template(\n        v-else-if=\"currentMode === 'year'\"\n      )\n        .dito-calendar-header\n          a.dito-calendar-step-prev(\n            @click=\"stepDecade(-1)\"\n          )\n          span {{ decadeToString(currentValue) }}\n          a.dito-calendar-step-next(\n            @click=\"stepDecade(1)\"\n          )\n        .dito-calendar-body\n          .dito-calendar-years\n            span(\n              v-for=\"year in yearRange\"\n              :class=\"getYearClass(year)\"\n              @click=\"selectYear(year)\"\n            ) {{ year }}\n","// Derived from ATUI, and further extended: https://aliqin.github.io/atui/\n\n<template lang=\"pug\">\n  .dito-calendar\n    .dito-calendar-popup\n      .dito-calendar-inner\n        template(\n          v-if=\"currentMode === 'day'\"\n        )\n          .dito-calendar-header\n            a.dito-calendar-step-prev.dito-calendar-step-year(\n              @click=\"stepYear(-1)\"\n            )\n            a.dito-calendar-step-prev.dito-calendar-step-month(\n              @click=\"stepMonth(-1)\"\n            )\n            span\n              a.dito-calendar-select-year(\n                @click=\"setMode('year')\"\n              ) {{ dateToString(currentValue, { year: 1 }) }}\n              a.dito-calendar-select-month(\n                @click=\"setMode('month')\"\n              ) {{ dateToString(currentValue, { month: 1 }) }}\n            a.dito-calendar-step-next.dito-calendar-step-month(\n              @click=\"stepMonth(1)\"\n            )\n            a.dito-calendar-step-next.dito-calendar-step-year(\n              @click=\"stepYear(1)\"\n            )\n          .dito-calendar-body\n            .dito-calendar-weekdays\n              span(\n                v-for=\"weekday in weekdayNames\"\n              ) {{ weekday.short }}\n            .dito-calendar-dates\n              span(\n                v-for=\"date in dateRange\"\n                :class=\"date.state && `dito-calendar-item-${date.state}`\"\n                @click=\"selectDate(date.date, date.state, true)\"\n              ) {{ date.text }}\n          .dito-calendar-footer\n            a.dito-calendar-select-today(\n              role=\"button\"\n              @click=\"selectDate(new Date())\"\n              :title=\"dateToString(new Date(), { year: 1, month: 1, day: 1 })\"\n            )\n        template(\n          v-else-if=\"currentMode === 'month'\"\n        )\n          .dito-calendar-header\n            a.dito-calendar-step-prev(\n              @click=\"stepYear(-1)\"\n            )\n            span\n              a.dito-calendar-select-year(\n                @click=\"setMode('year')\"\n              ) {{ dateToString(currentValue, { year: 1 }) }}\n            a.dito-calendar-step-next(\n              @click=\"stepYear(1)\"\n            )\n          .dito-calendar-body\n            .dito-calendar-months\n              span(\n                v-for=\"(month, index) in monthNames\"\n                :class=\"getMonthClass(index)\"\n                @click=\"selectMonth(index)\"\n              ) {{ month.short }}\n        template(\n          v-else-if=\"currentMode === 'year'\"\n        )\n          .dito-calendar-header\n            a.dito-calendar-step-prev(\n              @click=\"stepDecade(-1)\"\n            )\n            span {{ decadeToString(currentValue) }}\n            a.dito-calendar-step-next(\n              @click=\"stepDecade(1)\"\n            )\n          .dito-calendar-body\n            .dito-calendar-years\n              span(\n                v-for=\"year in yearRange\"\n                :class=\"getYearClass(year)\"\n                @click=\"selectYear(year)\"\n              ) {{ year }}\n</template>\n\n<style lang=\"sass\">\n  .dito-calendar\n    min-width: 240px\n    box-sizing: border-box\n\n  .dito-calendar-popup\n    border: $border-style\n    border-radius: $border-radius\n    background: $color-white\n    box-shadow: $shadow-window\n    z-index: 1000\n\n  .dito-calendar-body\n    padding: 0 0.5em\n    span\n      display: inline-block\n      width: calc(100% / 7)\n      height: $input-height\n      line-height: calc(#{$input-height} - 2px)\n      box-sizing: border-box\n      border-radius: $border-radius\n      border: $border-width solid transparent\n      text-align: center\n    .dito-calendar-item-today\n      border: $border-width solid $color-active\n      color: $color-active\n    .dito-calendar-item-active\n      &,\n      &:hover\n        background: $color-active\n        color: white\n    .dito-calendar-item-disabled\n      background: white\n      cursor: default\n    .dito-calendar-item-disabled,\n    .dito-calendar-item-gray\n      color: #999\n\n  .dito-calendar-months,\n  .dito-calendar-years\n    span\n      width: calc(100% / 4)\n      margin: 0.5em 0\n\n  .dito-calendar-years span\n    width: calc(100% / 5)\n\n  .dito-calendar a,\n  .dito-calendar-dates span,\n  .dito-calendar-months span,\n  .dito-calendar-years span\n    +user-select(none)\n    white-space: nowrap\n    cursor: pointer\n\n  .dito-calendar-header span\n    cursor: default\n    a\n      padding: 0 0.2em\n\n  .dito-calendar-dates span:hover,\n  .dito-calendar-months span:hover,\n  .dito-calendar-years span:hover,\n  .dito-calendar:not(:hover) .dito-calendar-item-current\n    background: $color-highlight\n\n  .dito-calendar-weekdays span\n    font-weight: bold\n    +user-select(none)\n\n  .dito-calendar-header,\n  .dito-calendar-footer\n    @extend %input-height\n    position: relative\n    text-align: center\n\n  .dito-calendar-footer\n    border-top: $border-style\n\n  .dito-calendar-header\n    font-weight: bold\n    border-bottom: $border-style\n    display: flex\n    > span\n      margin: auto\n      padding: 0 0.5em\n    a\n      font-weight: bold\n      &:hover\n        color: $color-active\n\n  .dito-calendar-step-prev,\n  .dito-calendar-step-next\n    position: relative\n    width: 5%\n    min-width: 2em\n    max-width: 3em\n    &::after\n      position: absolute\n      left: 0\n      right: 0\n      font-size: 1.25em\n  .dito-calendar-step-prev\n    &::after\n      content: '‹'\n    &.dito-calendar-step-year::after\n      content: '«'\n  .dito-calendar-step-next\n    &::after\n      content: '›'\n    &.dito-calendar-step-year::after\n      content: '»'\n\n  .dito-calendar-select-today\n    &::after\n      content: 'Now'\n</style>\n\n<script>\nimport { copyDate } from '../utils/index.js'\n\nexport default {\n  props: {\n    value: { type: Date, default: null },\n    locale: { type: String, default: 'en-US' },\n    disabledDate: { type: Function, default: () => false },\n    mode: { type: String, default: 'day' }\n  },\n\n  data() {\n    const { weekdayNames, monthNames } = getLocaleNames(this.locale)\n    return {\n      weekdayNames,\n      monthNames,\n      dateRange: [],\n      yearRange: [],\n      currentValue:\n        this.value ||\n        // If no value is provided, use current date but clear time fields:\n        copyDate(new Date(), { hour: 0, minute: 0, second: 0 }),\n      currentMode: this.mode\n    }\n  },\n\n  watch: {\n    currentValue: 'updateDateRange',\n    disabledDate: 'updateDateRange',\n\n    value(newVal, oldVal) {\n      if (+newVal !== +oldVal) {\n        this.currentValue = newVal || new Date()\n      }\n    },\n\n    mode(mode) {\n      this.currentMode = mode\n    }\n  },\n\n  mounted() {\n    this.updateDateRange()\n  },\n\n  methods: {\n    getMonthClass(month) {\n      return {\n        'dito-calendar-item-active':\n          this.value && month === this.value.getMonth() &&\n          this.currentValue.getFullYear() === this.value.getFullYear(),\n        'dito-calendar-item-current':\n          month === this.currentValue.getMonth()\n      }\n    },\n\n    getYearClass(year) {\n      return {\n        'dito-calendar-item-active':\n          this.value && year === this.value.getFullYear(),\n        'dito-calendar-item-current':\n          year === this.currentValue.getFullYear()\n      }\n    },\n\n    setDate(overrides) {\n      this.currentValue = copyDate(this.currentValue, overrides)\n    },\n\n    stepDecade(step) {\n      this.setDate({\n        year: this.currentValue.getFullYear() + step * 10\n      })\n    },\n\n    setMode(mode) {\n      this.currentMode = mode\n    },\n\n    stepMonth(step) {\n      const { currentValue } = this\n      const { year, month } = this.getYearMonth(\n        currentValue.getFullYear(),\n        currentValue.getMonth() + step\n      )\n      this.setDate({\n        month,\n        day: Math.min(\n          this.getDayCount(year, month),\n          this.currentValue.getDate()\n        )\n      })\n    },\n\n    stepYear(step) {\n      this.setDate({\n        year: this.currentValue.getFullYear() + step\n      })\n    },\n\n    selectDate(date, state, copy = false) {\n      if (state !== 'disabled') {\n        if (copy) {\n          this.setDate({\n            year: date.getFullYear(),\n            month: date.getMonth(),\n            day: date.getDate()\n          })\n        } else {\n          this.currentValue = date\n        }\n        this.$emit('input', this.currentValue)\n      }\n    },\n\n    selectMonth(month) {\n      this.setMode('day')\n      this.setDate({ month })\n    },\n\n    selectYear(year) {\n      this.setMode('month')\n      this.setDate({ year })\n    },\n\n    getYearMonth(year, month) {\n      if (month > 11) {\n        year++\n        month = 0\n      } else if (month < 0) {\n        year--\n        month = 11\n      }\n      return { year, month }\n    },\n\n    dateToString(date, { year, month, day }) {\n      return date.toLocaleString(this.locale, {\n        year: year && 'numeric',\n        month: month && 'long',\n        day: day && 'numeric'\n      })\n    },\n\n    decadeToString(date) {\n      const year = this.getFirstYearOfDecade(date.getFullYear())\n      return `${year} – ${year + 9}`\n    },\n\n    getDayCount(year, month) {\n      const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]\n      // Handle leap year:\n      return month === 1 && (!(year % 400) || !(year % 4) && (year % 100))\n        ? 29\n        : daysInMonth[month]\n    },\n\n    getFirstYearOfDecade(year) {\n      const yearStr = year.toString()\n      return +`${yearStr.slice(0, -1)}0`\n    },\n\n    navigate({ hor, ver, enter }) {\n      const { currentMode, currentValue } = this\n      if (hor || ver) {\n        switch (currentMode) {\n        case 'day':\n          this.setDate({\n            day: currentValue.getDate() + hor + ver * 7\n          })\n          break\n        case 'month':\n          this.setDate({\n            month: currentValue.getMonth() + hor + ver * 6\n          })\n          break\n        case 'year':\n          this.setDate({\n            year: currentValue.getFullYear() + hor + ver * 5\n          })\n          break\n        }\n        return true\n      } else if (enter) {\n        switch (currentMode) {\n        case 'day':\n          this.selectDate(currentValue)\n          break\n        case 'month':\n          this.setMode('day')\n          break\n        case 'year':\n          this.setMode('month')\n          break\n        }\n        return true\n      }\n    },\n\n    updateDateRange() {\n      this.dateRange = []\n      this.yearRange = []\n\n      const { currentValue } = this\n      const year = currentValue.getFullYear()\n      const month = currentValue.getMonth()\n      const startYear = this.getFirstYearOfDecade(year)\n      for (let i = 0; i < 10; i++) {\n        this.yearRange.push(startYear + i)\n      }\n      const currMonthFirstDay = new Date(year, month, 1)\n      let firstDayWeek = currMonthFirstDay.getDay() + 1\n      if (firstDayWeek === 0) {\n        firstDayWeek = 7\n      }\n      const dayCount = this.getDayCount(year, month)\n      if (firstDayWeek > 1) {\n        const prevMonth = this.getYearMonth(year, month - 1)\n        const prevMonthDayCount = this.getDayCount(\n          prevMonth.year,\n          prevMonth.month\n        )\n        for (let i = 1; i < firstDayWeek; i++) {\n          const day = prevMonthDayCount - firstDayWeek + i + 1\n          const date = new Date(prevMonth.year, prevMonth.month, day)\n          this.dateRange.push({\n            text: day,\n            date,\n            state: this.disabledDate(date) ? 'disabled' : 'gray'\n          })\n        }\n      }\n\n      const today = new Date()\n      for (let i = 1; i <= dayCount; i++) {\n        const date = new Date(year, month, i)\n        const isDay = date => date &&\n          date.getDate() === i &&\n          date.getFullYear() === year &&\n          date.getMonth() === month\n        const state = isDay(this.value) ? 'active'\n          : isDay(today) ? 'today'\n          : this.disabledDate(date) ? 'disabled'\n          : isDay(currentValue) ? 'current'\n          : null\n        this.dateRange.push({\n          text: i,\n          date,\n          state\n        })\n      }\n\n      const nextMonthNeed = 42 - this.dateRange.length\n      if (nextMonthNeed > 0) {\n        const nextMonth = this.getYearMonth(year, month + 1)\n        for (let i = 1; i <= nextMonthNeed; i++) {\n          const date = new Date(nextMonth.year, nextMonth.month, i)\n          const state = this.disabledDate(date) ? 'disabled' : 'gray'\n          this.dateRange.push({\n            text: i,\n            date,\n            state\n          })\n        }\n      }\n    }\n  }\n}\n\nconst localeNames = {}\n\n// Calling `toLocaleString()` this much appears to be expensive, so cache it:\nfunction getLocaleNames(locale) {\n  let names = localeNames[locale]\n  if (!names) {\n    const weekdayNames = []\n    for (let i = 0; i < 7; i++) {\n      const date = new Date(0, 0, i)\n      weekdayNames.push({\n        long: date.toLocaleString(locale, { weekday: 'long' }),\n        short: date.toLocaleString(locale, { weekday: 'short' })\n      })\n    }\n    const monthNames = []\n    for (let i = 1; i <= 12; i++) {\n      const date = new Date(0, i, 0)\n      monthNames.push({\n        long: date.toLocaleString(locale, { month: 'long' }),\n        short: date.toLocaleString(locale, { month: 'short' })\n      })\n    }\n    names = localeNames[locale] = {\n      weekdayNames,\n      monthNames\n    }\n  }\n  return names\n}\n</script>\n","\n.dito-trigger-container\n  .dito-trigger(\n    v-if=\"alwaysShow\"\n    ref=\"trigger\"\n    :class=\"triggerClass\"\n  )\n    slot(name=\"trigger\")\n  .dito-trigger(\n    v-else-if=\"trigger === 'click'\"\n    ref=\"trigger\"\n    :class=\"triggerClass\"\n    @click=\"onClick\"\n  )\n    slot(name=\"trigger\")\n  .dito-trigger(\n    v-else-if=\"trigger === 'hover'\"\n    ref=\"trigger\"\n    :class=\"triggerClass\"\n    @mouseenter=\"onHover(true)\"\n    @mouseleave=\"onHover(false)\"\n  )\n    slot(name=\"trigger\")\n  .dito-trigger(\n    v-else-if=\"trigger === 'focus' || trigger === 'always'\"\n    ref=\"trigger\"\n    :class=\"triggerClass\"\n  )\n    slot(name=\"trigger\")\n  transition(:name=\"transition\")\n    .dito-popup(\n      v-if=\"trigger === 'hover'\"\n      ref=\"popup\"\n      v-show=\"showPopup\"\n      :class=\"popupClass\"\n      :style=\"popupStyle\"\n      @mouseenter=\"onHover(true)\"\n      @mouseleave=\"onHover(false)\"\n    )\n      slot(\n        name=\"popup\"\n        v-if=\"showPopup\"\n      )\n    .dito-popup(\n      v-else\n      ref=\"popup\"\n      v-show=\"showPopup\"\n      :class=\"popupClass\"\n      :style=\"popupStyle\"\n    )\n      slot(\n        name=\"popup\"\n        v-if=\"showPopup\"\n      )\n","// Derived from ATUI, and further extended: https://aliqin.github.io/atui/\n\n<template lang=\"pug\">\n  .dito-trigger-container\n    .dito-trigger(\n      v-if=\"alwaysShow\"\n      ref=\"trigger\"\n      :class=\"triggerClass\"\n    )\n      slot(name=\"trigger\")\n    .dito-trigger(\n      v-else-if=\"trigger === 'click'\"\n      ref=\"trigger\"\n      :class=\"triggerClass\"\n      @click=\"onClick\"\n    )\n      slot(name=\"trigger\")\n    .dito-trigger(\n      v-else-if=\"trigger === 'hover'\"\n      ref=\"trigger\"\n      :class=\"triggerClass\"\n      @mouseenter=\"onHover(true)\"\n      @mouseleave=\"onHover(false)\"\n    )\n      slot(name=\"trigger\")\n    .dito-trigger(\n      v-else-if=\"trigger === 'focus' || trigger === 'always'\"\n      ref=\"trigger\"\n      :class=\"triggerClass\"\n    )\n      slot(name=\"trigger\")\n    transition(:name=\"transition\")\n      .dito-popup(\n        v-if=\"trigger === 'hover'\"\n        ref=\"popup\"\n        v-show=\"showPopup\"\n        :class=\"popupClass\"\n        :style=\"popupStyle\"\n        @mouseenter=\"onHover(true)\"\n        @mouseleave=\"onHover(false)\"\n      )\n        slot(\n          name=\"popup\"\n          v-if=\"showPopup\"\n        )\n      .dito-popup(\n        v-else\n        ref=\"popup\"\n        v-show=\"showPopup\"\n        :class=\"popupClass\"\n        :style=\"popupStyle\"\n      )\n        slot(\n          name=\"popup\"\n          v-if=\"showPopup\"\n        )\n</template>\n\n<style lang=\"sass\">\n  @import '../styles/transitions/index.sass'\n\n  .dito-trigger-container\n    position: relative\n\n  .dito-trigger-disabled\n    color: $color-disabled\n    border-color: $border-color\n    cursor: default\n    *\n      cursor: default !important\n      +user-select(none)\n      &:focus\n        box-shadow: none\n\n  .dito-popup\n    position: absolute\n    top: 0\n    left: 0\n    z-index: 1000\n</style>\n\n<script>\nimport { isString, hyphenate } from '@ditojs/utils'\nimport { addEvents } from '../utils/index.js'\n\nexport default {\n  props: {\n    trigger: { type: String, default: 'click' },\n    transition: { type: String, default: 'slide' },\n    placement: { type: String, default: 'bottom' },\n    show: { type: Boolean, default: false },\n    disabled: { type: Boolean, default: false },\n    target: { type: [String, HTMLElement], default: null },\n    customClass: { type: String, default: null },\n    zIndex: { type: Number, default: 0 },\n    keepInView: { type: Boolean, default: true },\n    hideWhenClickOutside: { type: Boolean, default: true },\n    alwaysShow: { type: Boolean, default: false },\n    cover: { type: Boolean, default: false },\n    hideDelay: { type: Number, default: 0 }\n  },\n\n  data() {\n    return {\n      showPopup: this.show,\n      popupPlacement: this.placement\n    }\n  },\n\n  computed: {\n    triggerClass() {\n      return {\n        'dito-trigger-disabled': this.disabled\n      }\n    },\n\n    popupClass() {\n      const classes = {\n        [`dito-popup-${hyphenate(this.placement)}`]: true\n      }\n      if (this.customClass) {\n        classes[this.customClass] = true\n      }\n      return classes\n    },\n\n    popupStyle() {\n      return this.zIndex ? `z-index: ${this.zIndex}` : ''\n    }\n  },\n\n  watch: {\n    show(show) {\n      this.showPopup = show || this.alwaysShow\n    },\n\n    showPopup(newVal, oldVal) {\n      if (!newVal !== !oldVal) {\n        this.$emit('update:show', newVal)\n        if (newVal) {\n          this.$nextTick(() => this.updatePosition())\n        }\n      }\n    }\n  },\n\n  mounted() {\n    const { trigger, popup } = this.$refs\n    if (this.trigger === 'focus') {\n      const target = trigger.querySelector('input, textarea')\n      if (target) {\n        this.focusEvents = addEvents(target, {\n          focus: () => {\n            this.showPopup = true\n          },\n          blur: () => {\n            this.showPopup = false\n          }\n        })\n      }\n    }\n\n    if (this.hideWhenClickOutside && !this.alwaysShow) {\n      // Use 'mouseup' instead of 'click', since click appears to happen after\n      // the DOM inside of popups could change in a way so that the check\n      // `popup.contains(event.target)` would fail:\n      this.closeEvents = addEvents(window, {\n        mouseup: event => {\n          if (\n            this.showPopup &&\n            !popup.contains(event.target) &&\n            !trigger.contains(event.target)\n          ) {\n            this.showPopup = false\n          }\n        },\n\n        blur: () => {\n          this.showPopup = false\n        }\n      })\n    }\n\n    if (this.alwaysShow) {\n      this.showPopup = true\n    }\n  },\n\n  created() {\n    this.showPopup = this.show\n  },\n\n  beforeDestroy() {\n    this.focusEvents?.remove()\n    this.closeEvents?.remove()\n    this.mouseLeaveTimer = null\n  },\n\n  methods: {\n    updatePosition() {\n      const { trigger, popup } = this.$refs\n      if (this.show && popup.offsetWidth === 0) {\n        setTimeout(() => this.updatePosition(), 0)\n        return\n      }\n\n      const target = isString(this.target)\n        ? this.$refs[this.target]\n        : this.target\n      if (target) {\n        // Actually resize the popup's first child, so they can set size limits.\n        const el = target === popup ? trigger : popup.firstChild\n        el.style.width = getComputedStyle(target).width\n      }\n\n      const bounds = (target || trigger).getBoundingClientRect()\n      const triggerLeft = bounds.left + window.scrollX\n      const triggerTop = bounds.top + window.scrollY\n      const triggerWidth = bounds.width\n      const triggerHeight = bounds.height\n      const popupWidth = popup.offsetWidth\n      const popupHeight = popup.offsetHeight\n\n      let [part1, part2] = this.popupPlacement.split('-') || []\n      if (this.keepInView) {\n        const winWidth = window.innerWidth\n        const winHeight = window.innerHeight\n        if (part1 === 'top') {\n          if (triggerTop < popupHeight) {\n            part1 = 'bottom'\n          }\n        } else if (part1 === 'bottom') {\n          if (winHeight - triggerTop - triggerHeight < popupHeight) {\n            part1 = 'top'\n          }\n        } else if (part1 === 'left') {\n          if (triggerLeft < popupWidth) {\n            part1 = 'right'\n          }\n        } else if (part1 === 'right') {\n          if (winWidth - triggerLeft - triggerWidth < popupWidth) {\n            part1 = 'left'\n          }\n        }\n\n        if (part2 === 'top') {\n          if (winHeight - triggerTop < popupHeight) {\n            part2 = 'bottom'\n          }\n        } else if (part2 === 'bottom') {\n          if (triggerTop + triggerHeight < popupHeight) {\n            part2 = 'top'\n          }\n        } else if (part2 === 'left') {\n          if (winWidth - triggerLeft < popupWidth) {\n            part2 = 'right'\n          }\n        } else if (part2 === 'right') {\n          if (triggerLeft + triggerWidth < popupWidth) {\n            part2 = 'left'\n          }\n        }\n      }\n\n      let left = 0\n      let top = 0\n      switch (part1) {\n      case 'top':\n        top -= popupHeight\n        break\n      case 'left':\n        left -= popupWidth\n        break\n      case 'right':\n        left += triggerWidth\n        break\n      case 'bottom':\n        top += triggerHeight\n        break\n      }\n      switch (part2) {\n      case 'right':\n        left -= popupWidth - triggerWidth\n        break\n      case 'bottom':\n        top -= popupHeight - triggerHeight\n        break\n      }\n      if (this.cover) {\n        if (part1 === 'top') {\n          top += triggerHeight\n        } else if (part1 === 'bottom') {\n          top -= triggerHeight\n        }\n      }\n      if (target && target !== trigger) {\n        const triggerBounds = trigger.getBoundingClientRect()\n        left += triggerLeft - triggerBounds.left\n        top += triggerTop - triggerBounds.top\n      }\n      popup.style.left = `${left}px`\n      popup.style.top = `${top}px`\n\n      this.$emit('update-position', {\n        trigger,\n        popup,\n        placement: this.popupPlacement\n      })\n    },\n\n    onClick() {\n      if (!this.disabled) {\n        this.showPopup = !this.showPopup\n      }\n    },\n\n    onHover(enter) {\n      if (!this.disabled) {\n        clearTimeout(this.mouseLeaveTimer)\n        if (enter) {\n          this.showPopup = true\n        } else {\n          if (this.hideDelay) {\n            this.mouseLeaveTimer = setTimeout(() => {\n              this.showPopup = false\n            }, this.hideDelay)\n          } else {\n            this.showPopup = false\n          }\n        }\n      }\n    }\n  }\n}\n</script>\n","\n.dito-input\n  input(\n    ref=\"input\"\n    v-model=\"currentValue\"\n    v-bind=\"attributes\"\n    v-on=\"listeners\"\n    :aria-label=\"title\"\n  )\n","<template lang=\"pug\">\n  .dito-input\n    input(\n      ref=\"input\"\n      v-model=\"currentValue\"\n      v-bind=\"attributes\"\n      v-on=\"listeners\"\n      :aria-label=\"title\"\n    )\n</template>\n\n<style lang=\"sass\">\n  .dito-input\n    display: inline-block\n    @extend %input\n    input\n      // Inherit all styling from .dito-input\n      all: inherit\n      display: inline-block\n      width: 100%\n      border: 0\n      margin: 0\n      padding: 0\n</style>\n\n<script>\nexport default {\n  props: {\n    type: { type: String, default: 'text' },\n    value: { type: [String, Number], default: null },\n    id: { type: String, default: null },\n    name: { type: String, default: null },\n    title: { type: String, default: null },\n    disabled: { type: Boolean, default: false },\n    readonly: { type: Boolean, default: false },\n    placeholder: { type: String, default: null },\n    autocomplete: { type: String, default: 'off' }\n    /*\n    clearable: { type: Boolean, default: false }\n    suffixIcon: { type: String, default: null },\n    prefixIcon: { type: String, default: null }\n    */\n  },\n\n  data() {\n    return {\n      currentValue: this.value,\n      hovering: false,\n      focused: false\n    }\n  },\n\n  computed: {\n    attributes() {\n      const {\n        id,\n        name,\n        type,\n        size,\n        title,\n        disabled,\n        readonly,\n        placeholder,\n        autocomplete,\n        $attrs\n      } = this\n      return {\n        id,\n        name,\n        type,\n        size,\n        title,\n        disabled,\n        readonly,\n        placeholder,\n        autocomplete,\n        ...$attrs\n      }\n    },\n\n    listeners() {\n      // Remove 'input' listener because we're handling it separately below,\n      // but pass on all others to the wrapped native element:\n      const { input, ...listeners } = this.$listeners\n      return listeners\n    },\n\n    size() {\n      // Determine size based on min & max settings, if they're provided.\n      const { size, min, max } = this.$attrs\n      const getLength = value => value != null ? `${value}`.length : 0\n      return size || getLength(min) || getLength(max) || undefined\n    }\n  },\n\n  watch: {\n    value(newVal, oldVal) {\n      if (newVal !== oldVal) {\n        this.currentValue = newVal\n      }\n    },\n\n    currentValue(newVal) {\n      if (newVal !== this.value) {\n        this.$emit('input', newVal)\n      }\n    }\n  },\n\n  methods: {\n    focus() {\n      this.$refs.input.focus()\n    },\n\n    blur() {\n      this.$refs.input.blur()\n    }\n  }\n}\n</script>\n","\ntrigger.dito-date-picker(\n  ref=\"trigger\"\n  trigger=\"click\"\n  :show.sync=\"showPopup\"\n  v-bind=\"{ transition, placement, disabled, target }\"\n)\n  input-field.dito-date-picker-input(\n    slot=\"trigger\"\n    ref=\"input\"\n    type=\"text\"\n    :value=\"currentText\"\n    readonly\n    :class=\"{ 'dito-focus': showPopup }\"\n    @focus=\"inputFocused = true\"\n    @blur=\"inputFocused = false\"\n    @keydown=\"onKeyDown\"\n    v-bind=\"{ placeholder, disabled }\"\n  )\n  // icon(type=\"calendar\" :color=\"iconColor\")\n  calendar.dito-date-picker-popup(\n    slot=\"popup\"\n    ref=\"calendar\"\n    @input=\"selectDate\"\n    :value=\"currentValue\"\n    v-bind=\"{ locale, disabledDate }\"\n  )\n","// Derived from ATUI, and further extended: https://aliqin.github.io/atui/\n\n<template lang=\"pug\">\n  trigger.dito-date-picker(\n    ref=\"trigger\"\n    trigger=\"click\"\n    :show.sync=\"showPopup\"\n    v-bind=\"{ transition, placement, disabled, target }\"\n  )\n    input-field.dito-date-picker-input(\n      slot=\"trigger\"\n      ref=\"input\"\n      type=\"text\"\n      :value=\"currentText\"\n      readonly\n      :class=\"{ 'dito-focus': showPopup }\"\n      @focus=\"inputFocused = true\"\n      @blur=\"inputFocused = false\"\n      @keydown=\"onKeyDown\"\n      v-bind=\"{ placeholder, disabled }\"\n    )\n    // icon(type=\"calendar\" :color=\"iconColor\")\n    calendar.dito-date-picker-popup(\n      slot=\"popup\"\n      ref=\"calendar\"\n      @input=\"selectDate\"\n      :value=\"currentValue\"\n      v-bind=\"{ locale, disabledDate }\"\n    )\n</template>\n\n<style lang=\"sass\">\n  .dito-date-picker\n    min-width: 240px\n    .dito-input\n      font-variant-numeric: tabular-nums\n      cursor: pointer\n      width: 100%\n  .dito-date-picker-popup\n    margin: $popup-margin\n</style>\n\n<script>\nimport { format, defaultFormats } from '@ditojs/utils'\nimport Trigger from './Trigger.vue'\nimport Calendar from './Calendar.vue'\nimport InputField from './InputField.vue'\nimport { getKeyNavigation } from '../utils/index.js'\n\nexport default {\n  components: { Trigger, Calendar, InputField },\n\n  props: {\n    value: { type: Date, default: null },\n    transition: { type: String, default: 'slide' },\n    placement: { type: String, default: 'bottom-left' },\n    placeholder: { type: String, default: null },\n    locale: { type: String, default: 'en-US' },\n    dateFormat: { type: Object, default: () => defaultFormats.date },\n    show: { type: Boolean, default: false },\n    disabled: { type: Boolean, default: false },\n    target: { type: [String, HTMLElement], default: 'trigger' },\n    disabledDate: { type: Function, default: () => false }\n  },\n\n  data() {\n    return {\n      currentValue: this.value,\n      showPopup: this.show,\n      inputFocused: false,\n      changed: false\n    }\n  },\n\n  computed: {\n    focused() {\n      return this.inputFocused || this.showPopup\n    },\n\n    currentText() {\n      return format(this.currentValue, {\n        locale: this.locale,\n        date: this.dateFormat,\n        time: false\n      }) || ''\n    }\n  },\n\n  watch: {\n    value(newVal, oldVal) {\n      if (+newVal !== +oldVal) {\n        this.currentValue = newVal\n      }\n    },\n\n    currentValue(date) {\n      if (+date !== +this.value) {\n        this.changed = true\n        this.$emit('input', date)\n      }\n    },\n\n    show(show) {\n      this.showPopup = show\n    },\n\n    showPopup(newVal, oldVal) {\n      if (!newVal !== !oldVal) {\n        this.$emit('update:show', newVal)\n      }\n    },\n\n    focused(newVal, oldVal) {\n      if (!newVal !== !oldVal) {\n        this.$emit(newVal ? 'focus' : 'blur')\n      }\n    }\n  },\n\n  mounted() {\n    this.$on('blur', () => {\n      if (this.changed) {\n        this.changed = false\n        this.$emit('change', this.currentValue)\n      }\n    })\n  },\n\n  methods: {\n    selectDate(date) {\n      this.currentValue = date\n      this.showPopup = false\n    },\n\n    onKeyDown(event) {\n      if (this.$refs.calendar?.navigate(getKeyNavigation(event))) {\n        event.preventDefault()\n      }\n    },\n\n    focus() {\n      this.$refs.input.focus()\n    },\n\n    blur() {\n      this.$refs.input.blur()\n    }\n  }\n}\n</script>\n","\ntrigger.dito-time-picker(\n  ref=\"trigger\"\n  trigger=\"click\"\n  :show.sync=\"showPopup\"\n  v-bind=\"{ transition, placement, disabled, target }\"\n)\n  input-field.dito-time-picker-input(\n    slot=\"trigger\"\n    ref=\"input\"\n    type=\"text\"\n    :value=\"currentText\"\n    readonly\n    :class=\"{ 'dito-focus': showPopup }\"\n    @focus=\"inputFocused = true\"\n    @blur=\"inputFocused = false\"\n    @keydown=\"onKeyDown\"\n    v-bind=\"{ placeholder, disabled }\"\n  )\n  // icon(type=\"time\"\n  //   :color=\"disabled ? '#bfbfbf' : (text ? '#666' : '#bfbfbf')\"\n  // )\n  .dito-time-picker-popup(\n    slot=\"popup\"\n  )\n    .dito-time-picker-panel\n      ul.dito-time-picker-hour(\n        ref=\"hour\"\n        @mouseover=\"selection = 0\"\n      )\n        li(\n          v-for=\"index in 24\"\n          v-if=\"!disabledHour(index - 1)\"\n          :class=\"{ selected: hour === index - 1 }\"\n          @click=\"hour = index - 1\"\n        ) {{ leftPad(index - 1) }}\n    .dito-time-picker-panel\n      ul.dito-time-picker-minute(\n        ref=\"minute\"\n        @mouseover=\"selection = 1\"\n      )\n        li(\n          v-for=\"index in 60\"\n          v-if=\"!disabledMinute(index - 1)\"\n          :class=\"{ selected: minute === index - 1 }\"\n          @click=\"minute = index - 1\"\n        ) {{ leftPad(index - 1) }}\n    .dito-time-picker-panel\n      ul.dito-time-picker-second(\n        ref=\"second\"\n        @mouseover=\"selection = 2\"\n      )\n        li(\n          v-for=\"index in 60\"\n          v-if=\"!disabledSecond(index - 1)\"\n          :class=\"{ selected: second === index - 1 }\"\n          @click=\"second = index - 1\"\n        ) {{ leftPad(index - 1) }}\n","// Derived from ATUI, and further extended: https://aliqin.github.io/atui/\n\n<template lang=\"pug\">\n  trigger.dito-time-picker(\n    ref=\"trigger\"\n    trigger=\"click\"\n    :show.sync=\"showPopup\"\n    v-bind=\"{ transition, placement, disabled, target }\"\n  )\n    input-field.dito-time-picker-input(\n      slot=\"trigger\"\n      ref=\"input\"\n      type=\"text\"\n      :value=\"currentText\"\n      readonly\n      :class=\"{ 'dito-focus': showPopup }\"\n      @focus=\"inputFocused = true\"\n      @blur=\"inputFocused = false\"\n      @keydown=\"onKeyDown\"\n      v-bind=\"{ placeholder, disabled }\"\n    )\n    // icon(type=\"time\"\n    //   :color=\"disabled ? '#bfbfbf' : (text ? '#666' : '#bfbfbf')\"\n    // )\n    .dito-time-picker-popup(\n      slot=\"popup\"\n    )\n      .dito-time-picker-panel\n        ul.dito-time-picker-hour(\n          ref=\"hour\"\n          @mouseover=\"selection = 0\"\n        )\n          li(\n            v-for=\"index in 24\"\n            v-if=\"!disabledHour(index - 1)\"\n            :class=\"{ selected: hour === index - 1 }\"\n            @click=\"hour = index - 1\"\n          ) {{ leftPad(index - 1) }}\n      .dito-time-picker-panel\n        ul.dito-time-picker-minute(\n          ref=\"minute\"\n          @mouseover=\"selection = 1\"\n        )\n          li(\n            v-for=\"index in 60\"\n            v-if=\"!disabledMinute(index - 1)\"\n            :class=\"{ selected: minute === index - 1 }\"\n            @click=\"minute = index - 1\"\n          ) {{ leftPad(index - 1) }}\n      .dito-time-picker-panel\n        ul.dito-time-picker-second(\n          ref=\"second\"\n          @mouseover=\"selection = 2\"\n        )\n          li(\n            v-for=\"index in 60\"\n            v-if=\"!disabledSecond(index - 1)\"\n            :class=\"{ selected: second === index - 1 }\"\n            @click=\"second = index - 1\"\n          ) {{ leftPad(index - 1) }}\n</template>\n\n<style lang=\"sass\">\n  .dito-time-picker\n    .dito-input\n      width: 100%\n\n  .dito-time-picker-popup\n    max-width: 160px\n    margin: $popup-margin\n\n  $time-picker-line-height: 24px\n  .dito-time-picker\n    .dito-input\n      font-variant-numeric: tabular-nums\n      cursor: pointer\n      width: 100%\n      .dito-icon-time\n        display: block\n        position: absolute\n        top: 0\n        right: 7px\n        height: 100%\n\n  .dito-time-picker-popup\n    list-style: none\n    background: $color-white\n    border: $border-style\n    border-radius: $border-radius\n    box-shadow: $shadow-window\n    overflow: hidden\n\n  .dito-time-picker-popup .dito-time-picker-panel\n    float: left\n    border: $border-style\n    border-width: 0 1px 0\n    margin-left: -1px\n    box-sizing: border-box\n    width: calc(100% / 3 + 1px)\n    overflow: hidden\n    &:last-child\n      border-right: 0\n    ul\n      overflow-x: hidden\n      overflow-y: auto\n      list-style: none\n      width: 100%\n      margin: 0\n      // Hide scrollbar:\n      box-sizing: content-box\n      padding: 0 17px 0 0\n      height: 7 * $time-picker-line-height\n      & > li\n        box-sizing: content-box\n        background: $color-white\n        width: 100%\n        height: $time-picker-line-height\n        line-height: $time-picker-line-height\n        text-align: center\n        font-variant-numeric: tabular-nums\n        cursor: pointer\n        white-space: nowrap\n        overflow: hidden\n        +user-select(none)\n        &:first-child\n          margin-top: 3 * $time-picker-line-height\n        &:last-child\n          margin-bottom: 3 * $time-picker-line-height\n        &:hover\n          background: $color-highlight\n        &.selected,\n        &.selected:hover\n          color: $color-text-inverted\n          background: $color-active\n        &.disabled\n          cursor: default\n          color: $color-disabled\n        &.disabled:hover\n          background: transparent\n</style>\n\n<script>\nimport Trigger from './Trigger.vue'\nimport InputField from './InputField.vue'\nimport {\n  copyDate, scrollTo, setSelection, getKeyNavigation\n} from '../utils/index.js'\n\nexport default {\n  components: { Trigger, InputField },\n\n  props: {\n    value: { type: Date, default: null },\n    transition: { type: String, default: 'slide' },\n    placement: { type: String, default: 'bottom-left' },\n    placeholder: { type: String, default: null },\n    show: { type: Boolean, default: false },\n    disabled: { type: Boolean, default: false },\n    target: { type: [String, HTMLElement], default: 'trigger' },\n    disabledHour: { type: Function, default: () => false },\n    disabledMinute: { type: Function, default: () => false },\n    disabledSecond: { type: Function, default: () => false }\n  },\n\n  data() {\n    return {\n      currentValue: this.value,\n      showPopup: this.show,\n      inputFocused: false,\n      selection: 0,\n      changed: false\n    }\n  },\n\n  computed: {\n    focused() {\n      return this.inputFocused || this.showPopup\n    },\n\n    currentText() {\n      return this.currentValue\n        ? `${\n          this.leftPad(this.hour)}:${\n          this.leftPad(this.minute)}:${\n          this.leftPad(this.second)}`\n        : ''\n    },\n\n    currentDate() {\n      return (\n        this.currentValue ||\n        // Create a new Date() object with the time set to 0, to be used when\n        // first setting any of the times, for meaningful dates in case the\n        // object is shared with a DatePicker, e.g. through DateTimePicker.\n        copyDate(new Date(), { hour: 0, minute: 0, second: 0 })\n      )\n    },\n\n    hour: {\n      get() {\n        return this.currentDate.getHours()\n      },\n\n      set(hour) {\n        this.setTime({ hour })\n      }\n    },\n\n    minute: {\n      get() {\n        return this.currentDate.getMinutes()\n      },\n\n      set(minute) {\n        this.setTime({ minute })\n      }\n    },\n\n    second: {\n      get() {\n        return this.currentDate.getSeconds()\n      },\n\n      set(second) {\n        this.setTime({ second })\n      }\n    }\n  },\n\n  watch: {\n    value(newVal, oldVal) {\n      if (+newVal !== +oldVal) {\n        this.currentValue = newVal\n      }\n    },\n\n    currentValue(date) {\n      if (+date !== +this.value) {\n        this.changed = true\n        this.$emit('input', date)\n        this.scrollAll()\n      }\n    },\n\n    currentText: 'updateSelection',\n\n    selection: 'updateSelection',\n\n    show(show) {\n      this.showPopup = show\n    },\n\n    showPopup(newVal, oldVal) {\n      if (newVal) {\n        this.updateSelection()\n        this.scrollAll(0)\n      }\n      if (!newVal !== !oldVal) {\n        this.$emit('update:show', newVal)\n      }\n    },\n\n    focused(newVal, oldVal) {\n      if (!newVal !== !oldVal) {\n        this.$emit(newVal ? 'focus' : 'blur')\n      }\n    }\n  },\n\n  mounted() {\n    this.$on('blur', () => {\n      if (this.changed) {\n        this.changed = false\n        this.$emit('change', this.currentValue)\n      }\n    })\n  },\n\n  methods: {\n    leftPad(value) {\n      return ('0' + value).slice(-2)\n    },\n\n    setTime(param) {\n      this.currentValue = copyDate(this.currentDate, param)\n    },\n\n    updateSelection(force = false) {\n      if (this.showPopup || force) {\n        const start = 3 * this.selection\n        this.$nextTick(() => setSelection(this.$refs.input, start, start + 2))\n      }\n    },\n\n    scrollAll(duration = 100) {\n      const scroll = (ref, value) => {\n        const target = this.$refs[ref]\n        if (target) {\n          // First and alst one add 3 times the margin\n          const lineHeight = target.scrollHeight / (target.children.length + 6)\n          scrollTo(target, Math.round(value * lineHeight), duration)\n        }\n      }\n      this.$nextTick(() => {\n        scroll('hour', this.hour)\n        scroll('minute', this.minute)\n        scroll('second', this.second)\n      })\n    },\n\n    onKeyDown(event) {\n      const selected = ['hour', 'minute', 'second'][this.selection]\n      if (selected) {\n        const { hor, ver, enter } = getKeyNavigation(event)\n        if (hor) {\n          const value = this.selection + hor\n          this.selection =\n            value < 0 ? 2\n            : value > 2 ? 0\n            : value\n        } else if (ver) {\n          const value = this[selected] + ver\n          const { length } = this.$refs[selected].children\n          this[selected] =\n            value < 0 ? value + length\n            : value >= length ? value - length\n            : value\n        }\n        if (enter) {\n          this.showPopup = false\n        }\n        if (hor || ver || enter) {\n          this.updateSelection(true)\n          event.preventDefault()\n        }\n      }\n    },\n\n    focus() {\n      this.$refs.input.focus()\n    },\n\n    blur() {\n      this.$refs.input.blur()\n    }\n  }\n}\n</script>\n","\n.dito-date-time-picker(\n  ref=\"picker\"\n)\n  .dito-pickers(\n    :class=\"{ 'dito-focus': focused }\"\n  )\n    date-picker(\n      ref=\"date\"\n      v-model=\"currentValue\"\n      placement=\"bottom-left\"\n      :target=\"$refs.picker\"\n      :show.sync=\"showDate\"\n      @focus=\"dateFocused = true\"\n      @blur=\"dateFocused = false\"\n      v-bind=\"{ transition, placeholder, locale, dateFormat, disabled }\"\n    )\n    time-picker(\n      ref=\"time\"\n      v-model=\"currentValue\"\n      placeholder=\"\"\n      placement=\"bottom-right\"\n      :target=\"$refs.picker\"\n      :show.sync=\"showTime\"\n      @focus=\"timeFocused = true\"\n      @blur=\"timeFocused = false\"\n      v-bind=\"{ transition, disabled }\"\n    )\n","<template lang=\"pug\">\n  .dito-date-time-picker(\n    ref=\"picker\"\n  )\n    .dito-pickers(\n      :class=\"{ 'dito-focus': focused }\"\n    )\n      date-picker(\n        ref=\"date\"\n        v-model=\"currentValue\"\n        placement=\"bottom-left\"\n        :target=\"$refs.picker\"\n        :show.sync=\"showDate\"\n        @focus=\"dateFocused = true\"\n        @blur=\"dateFocused = false\"\n        v-bind=\"{ transition, placeholder, locale, dateFormat, disabled }\"\n      )\n      time-picker(\n        ref=\"time\"\n        v-model=\"currentValue\"\n        placeholder=\"\"\n        placement=\"bottom-right\"\n        :target=\"$refs.picker\"\n        :show.sync=\"showTime\"\n        @focus=\"timeFocused = true\"\n        @blur=\"timeFocused = false\"\n        v-bind=\"{ transition, disabled }\"\n      )\n</template>\n\n<style lang=\"sass\">\n  .dito-date-time-picker\n    .dito-pickers\n      @extend %input\n      padding: 0\n      display: flex\n      .dito-input\n        background: none\n        border: 0\n    .dito-date-picker\n      width: 60%\n      min-width: 6.9em\n      .dito-input\n        padding-right: 0\n    .dito-time-picker\n      width: 40%\n      min-width: 5.4em\n      .dito-input\n        padding-left: 0\n        text-align: right\n</style>\n\n<script>\nimport { defaultFormats } from '@ditojs/utils'\nimport DatePicker from './DatePicker.vue'\nimport TimePicker from './TimePicker.vue'\n\nexport default {\n  components: { DatePicker, TimePicker },\n\n  props: {\n    value: { type: Date, default: null },\n    transition: { type: String, default: 'slide' },\n    placeholder: { type: String, default: null },\n    dateFormat: { type: Object, default: () => defaultFormats.date },\n    locale: { type: String, default: 'en-US' },\n    disabled: { type: Boolean, default: false }\n  },\n\n  data() {\n    return {\n      currentValue: this.value,\n      showDate: false,\n      showTime: false,\n      dateFocused: false,\n      timeFocused: false,\n      changed: false\n    }\n  },\n\n  computed: {\n    focused() {\n      return this.dateFocused || this.timeFocused\n    }\n  },\n\n  watch: {\n    value(newVal, oldVal) {\n      if (+newVal !== +oldVal) {\n        this.currentValue = newVal\n      }\n    },\n\n    currentValue(date) {\n      if (+date !== +this.value) {\n        this.changed = true\n        this.$emit('input', date)\n      }\n    },\n\n    focused(newVal, oldVal) {\n      if (!newVal !== !oldVal) {\n        this.$emit(newVal ? 'focus' : 'blur')\n      }\n    }\n  },\n\n  mounted() {\n    this.$on('blur', () => {\n      if (this.changed) {\n        this.changed = false\n        this.$emit('change', this.currentValue)\n      }\n    })\n  },\n\n  methods: {\n    focus() {\n      this.$refs.date.focus()\n    },\n\n    blur() {\n      this.$refs.date.blur()\n      this.$refs.time.blur()\n    }\n  }\n}\n\n</script>\n","\ni.dito-icon(:class=\"`dito-icon-${name}`\")\n","<template lang=\"pug\">\n  i.dito-icon(:class=\"`dito-icon-${name}`\")\n</template>\n\n<style lang=\"sass\">\n  // `yarn build:icons` converts the icon SVG files to silent classes inside\n  // `src/styles/mixins/_icons.sass`, making them available to all other sass\n  // code through `_imports`.\n  // In order to be able to use them as normal CSS classes, convert them here:\n  @each $name in $icons\n    .dito-icon-#{$name}\n      @extend %icon-#{$name}\n</style>\n\n<script>\nexport default {\n  props: {\n    name: {\n      type: String,\n      required: true\n    }\n  }\n}\n</script>\n","\n.dito-pagination(\n  v-if=\"numPages > 1\"\n)\n  .dito-pagination-total(\n    v-if=\"showTotal\"\n  )\n    template(v-if=\"total > 0\") {{ first }} – {{ last }}\n    template(v-else) 0\n    |  / {{ total }}\n  .dito-buttons.dito-buttons-round\n    button.dito-button(\n      v-for=\"page in pageRange\"\n      @click=\"onClickPage(page)\"\n      :class=\"getPageClass(page)\"\n      :disabled=\"page.disabled\"\n    )\n      span(\n        v-if=\"page.text\"\n      ) {{ page.text }}\n","<template lang=\"pug\">\n  .dito-pagination(\n    v-if=\"numPages > 1\"\n  )\n    .dito-pagination-total(\n      v-if=\"showTotal\"\n    )\n      template(v-if=\"total > 0\") {{ first }} – {{ last }}\n      template(v-else) 0\n      |  / {{ total }}\n    .dito-buttons.dito-buttons-round\n      button.dito-button(\n        v-for=\"page in pageRange\"\n        @click=\"onClickPage(page)\"\n        :class=\"getPageClass(page)\"\n        :disabled=\"page.disabled\"\n      )\n        span(\n          v-if=\"page.text\"\n        ) {{ page.text }}\n</template>\n\n<style lang=\"sass\">\n  .dito-pagination\n    display: flex\n    .dito-pagination-total\n      +ellipsis\n      margin: 0 0.5em\n      line-height: $input-height\n    .dito-button\n      transition: all .3s ease, color 0s, background 0s, border 0s\n      font-variant-numeric: tabular-nums\n      padding: 0 0.5em\n      &-prev,\n      &-next\n        &::before\n          @extend %icon-arrow\n      &-prev::before\n        transform: scaleX(-1)\n      &-ellipsis-prev,\n      &-ellipsis-next\n        &::before\n          @extend %icon-ellipsis\n        &:hover::before\n          @extend %icon-chevrons\n        background: none\n        border: 0\n        padding: 0\n        margin: 0\n        color: $color-text\n        &:focus\n          color: $color-active\n        &:active\n          box-shadow: none\n      &-ellipsis-prev::before\n        transform: scaleX(-1)\n</style>\n\n<script>\nexport default {\n  props: {\n    total: { type: Number, default: 0 },\n    page: { type: Number, default: 1 },\n    pageSize: { type: Number, default: 10 },\n    showTotal: { type: Boolean, default: true }\n  },\n\n  data() {\n    return {\n      pageRange: [],\n      showPrev: true,\n      showNext: true,\n      numPages: 0,\n      currentPageSize: this.pageSize,\n      currentPage: this.page\n    }\n  },\n\n  computed: {\n    first() {\n      return (this.currentPage - 1) * this.currentPageSize + 1\n    },\n\n    last() {\n      return Math.min(this.first + this.currentPageSize - 1, this.total)\n    }\n  },\n\n  watch: {\n    total: 'updatePageRange',\n    showPrev: 'updatePageRange',\n    showNext: 'updatePageRange',\n\n    page(page) {\n      this.currentPage = page\n    },\n\n    pageSize(pageSize) {\n      this.currentPageSize = pageSize\n    },\n\n    currentPageSize(currentPageSize) {\n      this.numPages = Math.ceil(this.total / currentPageSize)\n      if (this.currentPage > this.numPages) {\n        this.currentPage = this.numPages\n      }\n      this.updatePageRange()\n      this.$emit('size-change', this.page, currentPageSize)\n    },\n\n    currentPage(newVal, oldVal) {\n      if (newVal !== oldVal) {\n        this.updatePageRange()\n        this.$emit('update:page', newVal)\n      }\n    }\n  },\n\n  created() {\n    this.currentPage = this.page\n    this.currentPageSize = this.pageSize\n  },\n\n  mounted() {\n    this.updatePageRange()\n  },\n\n  methods: {\n    onClickPage(page) {\n      if (page.index && !page.disabled && page.index !== this.currentPage) {\n        this.currentPage = page.index\n      }\n    },\n\n    getPageClass(page) {\n      const classes = {\n        'dito-selected': page.active\n      }\n      if (page.type) {\n        classes[`dito-button-${page.type}`] = true\n      }\n      return classes\n    },\n\n    updatePageRange() {\n      const { showPrev, showNext, total, currentPageSize, currentPage } = this\n      const showLength = showPrev + showNext + 1\n      const numPages = this.numPages = Math.ceil(total / currentPageSize)\n\n      let start = 1\n      let end = 1\n      if (numPages <= showLength) {\n        end = numPages\n      } else if (currentPage <= showPrev + 1) {\n        end = showLength\n      } else if (currentPage >= numPages - showNext) {\n        end = numPages\n        start = numPages - showLength + 1\n      } else {\n        start = currentPage - showPrev\n        end = currentPage + showNext\n      }\n\n      const pageRange = []\n      pageRange.push({\n        index: currentPage - 1,\n        type: 'prev',\n        disabled: currentPage <= 1\n      })\n      if (start >= 2) {\n        pageRange.push({ index: 1, text: 1 })\n      }\n      if (start > 2) {\n        pageRange.push({\n          index: Math.max(1, currentPage - 10),\n          type: 'ellipsis-prev'\n        })\n      }\n      for (let i = start; i <= end; i++) {\n        pageRange.push({\n          index: i,\n          text: i,\n          active: i === currentPage\n        })\n      }\n      if (end < numPages - 1) {\n        pageRange.push({\n          index: Math.min(numPages, currentPage + 10),\n          type: 'ellipsis-next'\n        })\n      }\n      if (end <= numPages - 1) {\n        pageRange.push({ index: numPages, text: numPages })\n      }\n      pageRange.push({\n        index: currentPage + 1,\n        type: 'next',\n        disabled: currentPage >= numPages\n      })\n\n      this.pageRange = pageRange\n    }\n  }\n}\n</script>\n","\n.dito-switch(\n  :class=\"classes\"\n  :style=\"styles\"\n)\n  .dito-switch-pane\n    input(\n      type=\"checkbox\"\n      ref=\"input\"\n      v-model=\"checked\"\n      v-bind=\"attributes\"\n    )\n    .dito-switch-button\n    span.dito-switch-label(\n      v-if=\"labels\"\n    )\n      slot(\n        v-if=\"checked\"\n        name=\"checked\"\n      ) {{ labels.checked || 'on' }}\n      slot(\n        v-else\n        name=\"unchecked\"\n      ) {{ labels.unchecked || 'off' }}\n","<template lang=\"pug\">\n  .dito-switch(\n    :class=\"classes\"\n    :style=\"styles\"\n  )\n    .dito-switch-pane\n      input(\n        type=\"checkbox\"\n        ref=\"input\"\n        v-model=\"checked\"\n        v-bind=\"attributes\"\n      )\n      .dito-switch-button\n      span.dito-switch-label(\n        v-if=\"labels\"\n      )\n        slot(\n          v-if=\"checked\"\n          name=\"checked\"\n        ) {{ labels.checked || 'on' }}\n        slot(\n          v-else\n          name=\"unchecked\"\n        ) {{ labels.unchecked || 'off' }}\n</template>\n\n<style lang=\"sass\">\n  .dito-switch\n    // Use whole multiples of `rem` for sizes and `px` margins/padding along\n    // with `calc()` to end up with even pixel sizes. `rem` is needed because we\n    // change `font-size` inside `.dito-switch-button`\n    --switch-width: 4rem\n    --switch-height: 2rem\n    --switch-margin: 2px\n    --switch-padding: 3px\n    --switch-speed: 300ms\n    --label-margin: 0.5em\n\n    --width: calc(var(--switch-width) - 2 * var(--switch-margin))\n    --height: calc(var(--switch-height) - 2 * var(--switch-margin))\n    --offset: calc(var(--width) - var(--height))\n\n    display: inline-block\n    position: relative\n    height: var(--switch-height)\n    // To make inline labels appear on consistent baseline:\n    vertical-align: -25%\n    +user-select(none)\n    .dito-switch-pane\n      position: relative\n      width: var(--width)\n      height: var(--height)\n    .dito-switch-pane,\n    .dito-switch-label\n      top: 50%\n      transform: translateY(-50%)\n    input\n      cursor: pointer\n      appearance: none\n      width: 100%\n      height: 100%\n      border-radius: 1em\n      background: $color-light\n      transition: border-color .3s, background-color .3s\n    .dito-switch-button\n      position: absolute\n      // Set font-size to height, so we can use width/height = 1em for circle:\n      font-size: calc(var(--height) - 2 * var(--switch-padding))\n      top: var(--switch-padding)\n      left: var(--switch-padding)\n      width: 1em\n      height: 1em\n      border-radius: 0.5em\n      box-sizing: border-box\n      background: $color-white\n      transition: transform var(--switch-speed)\n      transform: translateX(0)\n    .dito-switch-button,\n    .dito-switch-label\n      pointer-events: none\n    .dito-switch-label\n      position: absolute\n      right: var(--label-margin)\n      text-transform: uppercase\n      color: $color-white\n    &.dito-checked\n      input\n        background: $color-active\n      .dito-switch-button\n        transform: translateX(var(--offset))\n      .dito-switch-label\n        left: var(--label-margin)\n        right: unset\n    &.dito-disabled\n      @extend %button-disabled\n    &:focus-within:not(:hover)\n      .dito-switch-button\n        box-shadow: $shadow-focus\n</style>\n\n<script>\nexport default {\n  props: {\n    value: { type: Boolean, default: false },\n    id: { type: String, default: null },\n    name: { type: String, default: null },\n    disabled: { type: Boolean, default: false },\n    labels: { type: [Object, Boolean], default: false }\n  },\n\n  data() {\n    return {\n      checked: this.value\n    }\n  },\n\n  computed: {\n    classes() {\n      const { checked, disabled } = this\n      return {\n        'dito-checked': checked,\n        'dito-disabled': disabled\n      }\n    },\n\n    styles() {\n      const { labels: { checked, unchecked } = {} } = this\n      // Calculate `--switch-width` in `rem`, based on label length.\n      const length = Math.max(0, checked?.length, unchecked?.length)\n      return {\n        '--switch-width': length ? `${length * 1.5}rem` : null\n      }\n    },\n\n    attributes() {\n      const { id, name, disabled, $attrs } = this\n      return { id, name, disabled, ...$attrs }\n    }\n  },\n\n  watch: {\n    value(value) {\n      this.checked = value\n    },\n\n    checked(checked) {\n      if (checked !== this.value) {\n        this.$emit('input', checked)\n        this.$emit('change', checked)\n      }\n    }\n  },\n\n  methods: {\n    focus() {\n      this.$refs.input.focus()\n    }\n  }\n}\n</script>\n","<style lang=\"sass\">\n  $duration: 0.15s\n  .height-enter-active,\n  .height-leave-active\n    transition: height $duration $easeOutQuart\n    overflow: hidden\n  .height-enter-active\n    animation: slide-enter $duration $easeOutQuart\n  .height-leave-active\n    animation: slide-leave $duration $easeOutQuart\n  .height-enter,\n  .height-leave-to\n    height: 0\n</style>\n\n<script>\nexport default {\n  functional: true,\n\n  props: {\n    enabled: { type: Boolean, default: true }\n  },\n\n  render: (createElement, context) => createElement(\n    'transition',\n    context.props.enabled\n      ? {\n        props: { name: 'height' },\n        on: events\n      }\n      : {},\n    context.children\n  )\n}\n\nconst setStyle = (element, style) => Object.assign(element.style, style)\n\n// Force repaint to make sure the animation is triggered correctly.\nconst forceRepaint = element => getComputedStyle(element).height\n\nconst events = {\n  afterEnter(element) {\n    // A timepout before setting style is only really needed after calls to\n    // `forceRepaint()`, but using one here too preserves execution sequence so\n    // that the call from `enter()` can never outrun the one from `afterEnter()`\n    setTimeout(() => setStyle(element, { height: 'auto' }))\n  },\n\n  enter(element) {\n    const { width } = getComputedStyle(element)\n    setStyle(element, {\n      width,\n      position: 'absolute',\n      visibility: 'hidden',\n      height: 'auto'\n    })\n    const { height } = getComputedStyle(element)\n    setStyle(element, {\n      width: null,\n      position: null,\n      visibility: null,\n      height: 0\n    })\n    forceRepaint(element)\n    setTimeout(() => setStyle(element, { height }))\n  },\n\n  leave(element) {\n    const { height } = getComputedStyle(element)\n    setStyle(element, { height })\n    forceRepaint(element)\n    setTimeout(() => setStyle(element, { height: 0 }))\n  }\n}\n</script>\n"],"names":["pick","isDate","render","staticRenderFns","__vue2_script","hyphenate","isString","defaultFormats","format"],"mappings":"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"}