@ditojs/admin 2.92.0 → 2.94.1

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

@@ -0,0 +1,2729 @@
+import {
+  pick,
+  isDate,
+  hyphenate,
+  isString,
+  defaultFormats,
+  format
+} from '@ditojs/utils'
+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(
+    pick(year, date && date.getFullYear(), 0),
+    pick(month, date && date.getMonth(), 0),
+    pick(day, date && date.getDate(), 0),
+    pick(hour, date && date.getHours(), 0),
+    pick(minute, date && date.getMinutes(), 0),
+    pick(second, date && date.getSeconds(), 0),
+    pick(millisecond, date && date.getMilliseconds(), 0)
+  )
+}
+function convertDate(date) {
+  return 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-${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 = 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: () => 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 (
+        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: () => 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
+})()
+export {
+  Calendar,
+  DatePicker,
+  DateTimePicker,
+  Icon,
+  InputField,
+  Pagination,
+  SwitchButton,
+  TimePicker,
+  TransitionHeight,
+  Trigger,
+  addEvents,
+  convertDate,
+  copyDate,
+  getAbsoluteBoundingRect,
+  getKey,
+  getKeyNavigation,
+  scrollTo,
+  setSelection
+}
+// # sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"dito-ui.es.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":["render","staticRenderFns","__vue2_script"],"mappings":";;AAAO,iCAAiC,IAAI;AAC1C,QAAM,MAAM;AACZ,QAAM,MAAM;AACZ,QAAM,OAAO,IAAI;AAEjB,MAAI,UAAU,IAAI,gBAAgB,SAAY,IAAI,cAC7C,KAAI,mBAAmB,KAAK,cAAc,MAAM;AACrD,MAAI,UAAU,IAAI,gBAAgB,SAAY,IAAI,cAC7C,KAAI,mBAAmB,KAAK,cAAc,MAAM;AACrD,QAAM,OAAO,GAAG,sBAAuB;AACvC,MAAI,OAAO,MAAM;AACf,QAAI,SAAS,GAAG;AAIhB,WAAO,WAAW,MAAM;AACtB,iBAAW,OAAO;AAClB,iBAAW,OAAO;AAClB,eAAS,OAAO;AAAA,IACjB;AAAA,EACF;AACD,SAAO;AAAA,IACL,QAAQ,KAAK,SAAS;AAAA,IACtB,QAAQ,KAAK;AAAA,IACb,MAAM,KAAK,OAAO;AAAA,IAClB,OAAO,KAAK,QAAQ;AAAA,IACpB,KAAK,KAAK,MAAM;AAAA,IAChB,OAAO,KAAK;AAAA,EACb;AACH;AC3BO,kBAAkB,MACvB,EAAE,MAAM,OAAO,KAAK,MAAM,QAAQ,QAAQ,gBAAgB,CAAE,GAC5D;AACA,SAAO,IAAI,KACT,KAAK,MAAM,QAAQ,KAAK,YAAW,GAAI,CAAC,GACxC,KAAK,OAAO,QAAQ,KAAK,SAAQ,GAAI,CAAC,GACtC,KAAK,KAAK,QAAQ,KAAK,QAAO,GAAI,CAAC,GACnC,KAAK,MAAM,QAAQ,KAAK,SAAQ,GAAI,CAAC,GACrC,KAAK,QAAQ,QAAQ,KAAK,WAAU,GAAI,CAAC,GACzC,KAAK,QAAQ,QAAQ,KAAK,WAAU,GAAI,CAAC,GACzC,KAAK,aAAa,QAAQ,KAAK,gBAAe,GAAI,CAAC,CACpD;AACH;AAEO,qBAAqB,MAAM;AAChC,SAAO,OAAO,IAAI,IAAI,OAAO,OAAO,IAAI,KAAK,IAAI,IAAI;AACvD;AClBO,mBAAmB,QAAQ,SAAQ;AACxC,aAAW,QAAQ,SAAQ;AACzB,WAAO,iBAAiB,MAAM,QAAO,OAAO,KAAK;AAAA,EAClD;AACD,SAAO;AAAA,IACL,SAAS;AACP,iBAAW,QAAQ,SAAQ;AACzB,eAAO,oBAAoB,MAAM,QAAO,OAAO,KAAK;AAAA,MACrD;AAAA,IACF;AAAA,EACF;AACH;AAEO,gBAAgB,OAAO;AAC5B,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,EACR,EAAI,MAAM;AACV;AAEO,0BAA0B,OAAO;AACtC,QAAM,MAAM,OAAO,KAAK;AACxB,SAAO;AAAA,IACL,KAAK,EAAE,MAAM,IAAI,OAAO,EAAG,EAAC,QAAQ;AAAA,IACpC,KAAK,EAAE,IAAI,IAAI,MAAM,EAAG,EAAC,QAAQ;AAAA,IACjC,OAAO,QAAQ;AAAA,EAChB;AACH;AC9BO,kBAAkB,SAAS,IAAI,UAAU;AAC9C,QAAM,wBAAwB,OAAO,yBAAyB,WAAW;AACvE,WAAO,WAAW,UAAU,IAAI,EAAE;AAAA,EACnC;AACD,MAAI,YAAY,GAAG;AACjB,YAAQ,YAAY;AAAA,EACxB,OAAS;AACL,UAAM,aAAa,KAAK,QAAQ;AAChC,UAAM,UAAU,aAAa,WAAW;AACxC,0BAAsB,MAAM;AAC1B,cAAQ,YAAY,QAAQ,YAAY;AACxC,UAAI,QAAQ,cAAc;AAAI;AAC9B,eAAS,SAAS,IAAI,WAAW,EAAE;AAAA,IACzC,CAAK;AAAA,EACF;AACH;ACfO,sBAAsB,OAAO,OAAO,KAAK;AAC9C,MAAI,MAAM,iBAAiB;AACzB,UAAM,QAAQ,MAAM,gBAAiB;AACrC,UAAM,SAAS,IAAI;AACnB,UAAM,UAAU,aAAa,KAAK;AAClC,UAAM,QAAQ,aAAa,GAAG;AAC9B,UAAM,OAAQ;AACd,UAAM,MAAO;AAAA,EACjB,WAAa,MAAM,mBAAmB;AAClC,UAAM,MAAO;AACb,UAAM,kBAAkB,OAAO,GAAG;AAAA,EACtC,WAAa,oBAAoB,OAAO;AACpC,UAAM,iBAAiB;AACvB,UAAM,eAAe;AACrB,UAAM,MAAO;AAAA,EACd;AACH;AChBA,IAAIA,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,OAAO;AAAA,IACf,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,EACjB,GAAK,CAAC,IAAI,gBAAgB,QAAQ,CAAC,GAAG,OAAO;AAAA,IACzC,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,KAAK;AAAA,IACV,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,SAAS,EAAE;AAAA,MACvB;AAAA,IACF;AAAA,EACL,CAAG,GAAG,GAAG,KAAK;AAAA,IACV,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,UAAU,EAAE;AAAA,MACxB;AAAA,IACF;AAAA,EACF,CAAA,GAAG,GAAG,QAAQ,CAAC,GAAG,KAAK;AAAA,IACtB,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,QAAQ,MAAM;AAAA,MAC1B;AAAA,IACF;AAAA,EACL,GAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,aAAa,IAAI,cAAc;AAAA,IACnD,MAAM;AAAA,EACP,CAAA,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK;AAAA,IACd,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,QAAQ,OAAO;AAAA,MAC3B;AAAA,IACF;AAAA,EACL,GAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,aAAa,IAAI,cAAc;AAAA,IACnD,OAAO;AAAA,EACR,CAAA,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK;AAAA,IAChB,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,UAAU,CAAC;AAAA,MACvB;AAAA,IACF;AAAA,EACL,CAAG,GAAG,GAAG,KAAK;AAAA,IACV,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,SAAS,CAAC;AAAA,MACtB;AAAA,IACF;AAAA,EACL,CAAG,CAAC,CAAC,GAAG,GAAG,OAAO;AAAA,IACd,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,EACd,GAAE,IAAI,GAAG,IAAI,cAAc,SAAU,SAAS;AAC7C,WAAO,GAAG,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK,CAAC,CAAC,CAAC;AAAA,EAClD,CAAA,GAAG,CAAC,GAAG,GAAG,OAAO;AAAA,IAChB,aAAa;AAAA,EACd,GAAE,IAAI,GAAG,IAAI,WAAW,SAAU,MAAM;AACvC,WAAO,GAAG,QAAQ;AAAA,MAChB,OAAO,KAAK,SAAS,sBAAsB,KAAK;AAAA,MAChD,IAAI;AAAA,QACF,SAAS,SAAU,QAAQ;AACzB,iBAAO,IAAI,WAAW,KAAK,MAAM,KAAK,OAAO,IAAI;AAAA,QAClD;AAAA,MACF;AAAA,IACP,GAAO,CAAC,IAAI,GAAG,IAAI,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC;AAAA,EAC/B,CAAA,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,OAAO;AAAA,IAClB,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,KAAK;AAAA,IACV,aAAa;AAAA,IACb,OAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS,IAAI,aAAa,IAAI,KAAI,GAAI;AAAA,QACpC,MAAM;AAAA,QACN,OAAO;AAAA,QACP,KAAK;AAAA,MACb,CAAO;AAAA,IACF;AAAA,IACD,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,YAAI,WAAW,IAAI,KAAI,CAAE;AAAA,MAC1B;AAAA,IACF;AAAA,EACL,CAAG,CAAC,CAAC,CAAC,IAAI,IAAI,gBAAgB,UAAU,CAAC,GAAG,OAAO;AAAA,IAC/C,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,KAAK;AAAA,IACV,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,SAAS,EAAE;AAAA,MACvB;AAAA,IACF;AAAA,EACF,CAAA,GAAG,GAAG,QAAQ,CAAC,GAAG,KAAK;AAAA,IACtB,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,QAAQ,MAAM;AAAA,MAC1B;AAAA,IACF;AAAA,EACL,GAAK,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,aAAa,IAAI,cAAc;AAAA,IACnD,MAAM;AAAA,EACP,CAAA,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK;AAAA,IAChB,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,SAAS,CAAC;AAAA,MACtB;AAAA,IACF;AAAA,EACL,CAAG,CAAC,CAAC,GAAG,GAAG,OAAO;AAAA,IACd,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,EACjB,GAAK,IAAI,GAAG,IAAI,YAAY,SAAU,OAAO,QAAO;AAChD,WAAO,GAAG,QAAQ;AAAA,MAChB,OAAO,IAAI,cAAc,MAAK;AAAA,MAC9B,IAAI;AAAA,QACF,SAAS,SAAU,QAAQ;AACzB,iBAAO,IAAI,YAAY,MAAK;AAAA,QAC7B;AAAA,MACF;AAAA,IACP,GAAO,CAAC,IAAI,GAAG,IAAI,GAAG,MAAM,KAAK,CAAC,CAAC,CAAC;AAAA,EACpC,CAAG,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,gBAAgB,SAAS,CAAC,GAAG,OAAO;AAAA,IAClD,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,KAAK;AAAA,IACV,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,WAAW,EAAE;AAAA,MACzB;AAAA,IACF;AAAA,EACL,CAAG,GAAG,GAAG,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,eAAe,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,GAAG,KAAK;AAAA,IAC9E,aAAa;AAAA,IACb,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,eAAO,IAAI,WAAW,CAAC;AAAA,MACxB;AAAA,IACF;AAAA,EACL,CAAG,CAAC,CAAC,GAAG,GAAG,OAAO;AAAA,IACd,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,EACd,GAAE,IAAI,GAAG,IAAI,WAAW,SAAU,MAAM;AACvC,WAAO,GAAG,QAAQ;AAAA,MAChB,OAAO,IAAI,aAAa,IAAI;AAAA,MAC5B,IAAI;AAAA,QACF,SAAS,SAAU,QAAQ;AACzB,iBAAO,IAAI,WAAW,IAAI;AAAA,QAC3B;AAAA,MACF;AAAA,IACP,GAAO,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC;AAAA,EAC1B,CAAA,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,GAAI,CAAA,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9B;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC4CvB,MAAAE,kBAAA;AAAA,EACA,OAAA;AAAA,IACA,OAAA,EAAA,MAAA,MAAA,SAAA,KAAA;AAAA,IACA,QAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,cAAA,EAAA,MAAA,UAAA,SAAA,MAAA,MAAA;AAAA,IACA,MAAA,EAAA,MAAA,QAAA,SAAA,MAAA;AAAA,EACA;AAAA,EAEA,OAAA;AACA,UAAA,EAAA,cAAA,eAAA,eAAA,KAAA,MAAA;AACA,WAAA;AAAA,MACA;AAAA,MACA;AAAA,MACA,WAAA,CAAA;AAAA,MACA,WAAA,CAAA;AAAA,MACA,cACA,KAAA,SAEA,SAAA,IAAA,KAAA,GAAA,EAAA,MAAA,GAAA,QAAA,GAAA,QAAA,GAAA;AAAA,MACA,aAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,cAAA;AAAA,IACA,cAAA;AAAA,IAEA,MAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,eAAA,UAAA,IAAA,KAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,KAAA,MAAA;AACA,WAAA,cAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,SAAA,gBAAA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,cAAA,OAAA;AACA,aAAA;AAAA,QACA,6BACA,KAAA,SAAA,UAAA,KAAA,MAAA,SAAA,KACA,KAAA,aAAA,YAAA,MAAA,KAAA,MAAA,YAAA;AAAA,QACA,8BACA,UAAA,KAAA,aAAA,SAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA,MAAA;AACA,aAAA;AAAA,QACA,6BACA,KAAA,SAAA,SAAA,KAAA,MAAA,YAAA;AAAA,QACA,8BACA,SAAA,KAAA,aAAA,YAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA,WAAA;AACA,WAAA,eAAA,SAAA,KAAA,cAAA,SAAA;AAAA,IACA;AAAA,IAEA,WAAA,MAAA;AACA,WAAA,QAAA;AAAA,QACA,MAAA,KAAA,aAAA,YAAA,IAAA,OAAA;AAAA,MACA,CAAA;AAAA,IACA;AAAA,IAEA,QAAA,MAAA;AACA,WAAA,cAAA;AAAA,IACA;AAAA,IAEA,UAAA,MAAA;AACA,YAAA,EAAA,iBAAA;AACA,YAAA,EAAA,MAAA,UAAA,KAAA,aACA,aAAA,YAAA,GACA,aAAA,SAAA,IAAA,IACA;AACA,WAAA,QAAA;AAAA,QACA;AAAA,QACA,KAAA,KAAA,IACA,KAAA,YAAA,MAAA,KAAA,GACA,KAAA,aAAA,QAAA,CACA;AAAA,MACA,CAAA;AAAA,IACA;AAAA,IAEA,SAAA,MAAA;AACA,WAAA,QAAA;AAAA,QACA,MAAA,KAAA,aAAA,YAAA,IAAA;AAAA,MACA,CAAA;AAAA,IACA;AAAA,IAEA,WAAA,MAAA,OAAA,OAAA,OAAA;AACA,UAAA,UAAA,YAAA;AACA,YAAA,MAAA;AACA,eAAA,QAAA;AAAA,YACA,MAAA,KAAA,YAAA;AAAA,YACA,OAAA,KAAA,SAAA;AAAA,YACA,KAAA,KAAA,QAAA;AAAA,UACA,CAAA;AAAA,QACA,OAAA;AACA,eAAA,eAAA;AAAA,QACA;AACA,aAAA,MAAA,SAAA,KAAA,YAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,YAAA,OAAA;AACA,WAAA,QAAA,KAAA;AACA,WAAA,QAAA,EAAA,OAAA;AAAA,IACA;AAAA,IAEA,WAAA,MAAA;AACA,WAAA,QAAA,OAAA;AACA,WAAA,QAAA,EAAA,MAAA;AAAA,IACA;AAAA,IAEA,aAAA,MAAA,OAAA;AACA,UAAA,QAAA,IAAA;AACA;AACA,gBAAA;AAAA,MACA,WAAA,QAAA,GAAA;AACA;AACA,gBAAA;AAAA,MACA;AACA,aAAA,EAAA,MAAA,MAAA;AAAA,IACA;AAAA,IAEA,aAAA,MAAA,EAAA,MAAA,OAAA,OAAA;AACA,aAAA,KAAA,eAAA,KAAA,QAAA;AAAA,QACA,MAAA,QAAA;AAAA,QACA,OAAA,SAAA;AAAA,QACA,KAAA,OAAA;AAAA,MACA,CAAA;AAAA,IACA;AAAA,IAEA,eAAA,MAAA;AACA,YAAA,OAAA,KAAA,qBAAA,KAAA,YAAA,CAAA;AACA,aAAA,GAAA,eAAA,OAAA;AAAA,IACA;AAAA,IAEA,YAAA,MAAA,OAAA;AACA,YAAA,cAAA,CAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,IAAA,EAAA;AAEA,aAAA,UAAA,KAAA,EAAA,QAAA,QAAA,CAAA,QAAA,MAAA,OAAA,OACA,KACA,YAAA;AAAA,IACA;AAAA,IAEA,qBAAA,MAAA;AACA,YAAA,UAAA,KAAA,SAAA;AACA,aAAA,CAAA,GAAA,QAAA,MAAA,GAAA,EAAA;AAAA,IACA;AAAA,IAEA,SAAA,EAAA,KAAA,KAAA,SAAA;AACA,YAAA,EAAA,aAAA,iBAAA;AACA,UAAA,OAAA,KAAA;AACA,gBAAA;AAAA,eACA;AACA,iBAAA,QAAA;AAAA,cACA,KAAA,aAAA,QAAA,IAAA,MAAA,MAAA;AAAA,YACA,CAAA;AACA;AAAA,eACA;AACA,iBAAA,QAAA;AAAA,cACA,OAAA,aAAA,SAAA,IAAA,MAAA,MAAA;AAAA,YACA,CAAA;AACA;AAAA,eACA;AACA,iBAAA,QAAA;AAAA,cACA,MAAA,aAAA,YAAA,IAAA,MAAA,MAAA;AAAA,YACA,CAAA;AACA;AAAA;AAEA,eAAA;AAAA,MACA,WAAA,OAAA;AACA,gBAAA;AAAA,eACA;AACA,iBAAA,WAAA,YAAA;AACA;AAAA,eACA;AACA,iBAAA,QAAA,KAAA;AACA;AAAA,eACA;AACA,iBAAA,QAAA,OAAA;AACA;AAAA;AAEA,eAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,kBAAA;AACA,WAAA,YAAA,CAAA;AACA,WAAA,YAAA,CAAA;AAEA,YAAA,EAAA,iBAAA;AACA,YAAA,OAAA,aAAA,YAAA;AACA,YAAA,QAAA,aAAA,SAAA;AACA,YAAA,YAAA,KAAA,qBAAA,IAAA;AACA,eAAA,IAAA,GAAA,IAAA,IAAA,KAAA;AACA,aAAA,UAAA,KAAA,YAAA,CAAA;AAAA,MACA;AACA,YAAA,oBAAA,IAAA,KAAA,MAAA,OAAA,CAAA;AACA,UAAA,eAAA,kBAAA,OAAA,IAAA;AACA,UAAA,iBAAA,GAAA;AACA,uBAAA;AAAA,MACA;AACA,YAAA,WAAA,KAAA,YAAA,MAAA,KAAA;AACA,UAAA,eAAA,GAAA;AACA,cAAA,YAAA,KAAA,aAAA,MAAA,QAAA,CAAA;AACA,cAAA,oBAAA,KAAA,YACA,UAAA,MACA,UAAA,KACA;AACA,iBAAA,IAAA,GAAA,IAAA,cAAA,KAAA;AACA,gBAAA,MAAA,oBAAA,eAAA,IAAA;AACA,gBAAA,OAAA,IAAA,KAAA,UAAA,MAAA,UAAA,OAAA,GAAA;AACA,eAAA,UAAA,KAAA;AAAA,YACA,MAAA;AAAA,YACA;AAAA,YACA,OAAA,KAAA,aAAA,IAAA,IAAA,aAAA;AAAA,UACA,CAAA;AAAA,QACA;AAAA,MACA;AAEA,YAAA,QAAA,IAAA,KAAA;AACA,eAAA,IAAA,GAAA,KAAA,UAAA,KAAA;AACA,cAAA,OAAA,IAAA,KAAA,MAAA,OAAA,CAAA;AACA,cAAA,QAAA,WAAA,SACA,MAAA,QAAA,MAAA,KACA,MAAA,YAAA,MAAA,QACA,MAAA,SAAA,MAAA;AACA,cAAA,QAAA,MAAA,KAAA,KAAA,IAAA,WACA,MAAA,KAAA,IAAA,UACA,KAAA,aAAA,IAAA,IAAA,aACA,MAAA,YAAA,IAAA,YACA;AACA,aAAA,UAAA,KAAA;AAAA,UACA,MAAA;AAAA,UACA;AAAA,UACA;AAAA,QACA,CAAA;AAAA,MACA;AAEA,YAAA,gBAAA,KAAA,KAAA,UAAA;AACA,UAAA,gBAAA,GAAA;AACA,cAAA,YAAA,KAAA,aAAA,MAAA,QAAA,CAAA;AACA,iBAAA,IAAA,GAAA,KAAA,eAAA,KAAA;AACA,gBAAA,OAAA,IAAA,KAAA,UAAA,MAAA,UAAA,OAAA,CAAA;AACA,gBAAA,QAAA,KAAA,aAAA,IAAA,IAAA,aAAA;AACA,eAAA,UAAA,KAAA;AAAA,YACA,MAAA;AAAA,YACA;AAAA,YACA;AAAA,UACA,CAAA;AAAA,QACA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AACA;AAEA,MAAA,cAAA,CAAA;AAGA,wBAAA,QAAA;AACA,MAAA,QAAA,YAAA;AACA,MAAA,CAAA,OAAA;AACA,UAAA,eAAA,CAAA;AACA,aAAA,IAAA,GAAA,IAAA,GAAA,KAAA;AACA,YAAA,OAAA,IAAA,KAAA,GAAA,GAAA,CAAA;AACA,mBAAA,KAAA;AAAA,QACA,MAAA,KAAA,eAAA,QAAA,EAAA,SAAA,QAAA;AAAA,QACA,OAAA,KAAA,eAAA,QAAA,EAAA,SAAA,SAAA;AAAA,MACA,CAAA;AAAA,IACA;AACA,UAAA,aAAA,CAAA;AACA,aAAA,IAAA,GAAA,KAAA,IAAA,KAAA;AACA,YAAA,OAAA,IAAA,KAAA,GAAA,GAAA,CAAA;AACA,iBAAA,KAAA;AAAA,QACA,MAAA,KAAA,eAAA,QAAA,EAAA,OAAA,QAAA;AAAA,QACA,OAAA,KAAA,eAAA,QAAA,EAAA,OAAA,SAAA;AAAA,MACA,CAAA;AAAA,IACA;AACA,YAAA,YAAA,UAAA;AAAA,MACA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AACA,SAAA;AACA;;;;;;;;;;;;ACtfA,IAAIF,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,OAAO;AAAA,IACf,aAAa;AAAA,EACd,GAAE,CAAC,IAAI,aAAa,GAAG,OAAO;AAAA,IAC7B,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO,IAAI;AAAA,EACZ,GAAE,CAAC,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,IAAI,YAAY,UAAU,GAAG,OAAO;AAAA,IAC/D,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO,IAAI;AAAA,IACX,IAAI;AAAA,MACF,SAAS,IAAI;AAAA,IACd;AAAA,EACF,GAAE,CAAC,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,IAAI,YAAY,UAAU,GAAG,OAAO;AAAA,IAC/D,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO,IAAI;AAAA,IACX,IAAI;AAAA,MACF,cAAc,SAAU,QAAQ;AAC9B,eAAO,IAAI,QAAQ,IAAI;AAAA,MACxB;AAAA,MACD,cAAc,SAAU,QAAQ;AAC9B,eAAO,IAAI,QAAQ,KAAK;AAAA,MACzB;AAAA,IACF;AAAA,EACL,GAAK,CAAC,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,IAAI,YAAY,WAAW,IAAI,YAAY,WAAW,GAAG,OAAO;AAAA,IAC3F,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO,IAAI;AAAA,EACZ,GAAE,CAAC,IAAI,GAAG,SAAS,CAAC,GAAG,CAAC,IAAI,IAAI,MAAM,GAAG,cAAc;AAAA,IACtD,OAAO;AAAA,MACL,QAAQ,IAAI;AAAA,IACb;AAAA,EACF,GAAE,CAAC,IAAI,YAAY,UAAU,GAAG,OAAO;AAAA,IACtC,YAAY,CAAC;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,IAAI;AAAA,MACX,YAAY;AAAA,IAClB,CAAK;AAAA,IACD,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO,IAAI;AAAA,IACX,OAAO,IAAI;AAAA,IACX,IAAI;AAAA,MACF,cAAc,SAAU,QAAQ;AAC9B,eAAO,IAAI,QAAQ,IAAI;AAAA,MACxB;AAAA,MACD,cAAc,SAAU,QAAQ;AAC9B,eAAO,IAAI,QAAQ,KAAK;AAAA,MACzB;AAAA,IACF;AAAA,EACF,GAAE,CAAC,IAAI,YAAY,IAAI,GAAG,OAAO,IAAI,IAAI,GAAE,CAAE,GAAG,CAAC,IAAI,GAAG,OAAO;AAAA,IAC9D,YAAY,CAAC;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,IAAI;AAAA,MACX,YAAY;AAAA,IAClB,CAAK;AAAA,IACD,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO,IAAI;AAAA,IACX,OAAO,IAAI;AAAA,EACZ,GAAE,CAAC,IAAI,YAAY,IAAI,GAAG,OAAO,IAAI,IAAI,GAAE,CAAE,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AAC3D;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;ACavB,MAAAE,kBAAA;AAAA,EACA,OAAA;AAAA,IACA,SAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,YAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,WAAA,EAAA,MAAA,QAAA,SAAA,SAAA;AAAA,IACA,MAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,UAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,QAAA,EAAA,MAAA,CAAA,QAAA,WAAA,GAAA,SAAA,KAAA;AAAA,IACA,aAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,QAAA,EAAA,MAAA,QAAA,SAAA,EAAA;AAAA,IACA,YAAA,EAAA,MAAA,SAAA,SAAA,KAAA;AAAA,IACA,sBAAA,EAAA,MAAA,SAAA,SAAA,KAAA;AAAA,IACA,YAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,OAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,WAAA,EAAA,MAAA,QAAA,SAAA,EAAA;AAAA,EACA;AAAA,EAEA,OAAA;AACA,WAAA;AAAA,MACA,WAAA,KAAA;AAAA,MACA,gBAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AAAA,IACA,eAAA;AACA,aAAA;AAAA,QACA,yBAAA,KAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA;AACA,YAAA,UAAA;AAAA,QACA,CAAA,cAAA,UAAA,KAAA,SAAA,MAAA;AAAA,MACA;AACA,UAAA,KAAA,aAAA;AACA,gBAAA,KAAA,eAAA;AAAA,MACA;AACA,aAAA;AAAA,IACA;AAAA,IAEA,aAAA;AACA,aAAA,KAAA,SAAA,YAAA,KAAA,WAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,KAAA,MAAA;AACA,WAAA,YAAA,QAAA,KAAA;AAAA,IACA;AAAA,IAEA,UAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,MAAA,eAAA,MAAA;AACA,YAAA,QAAA;AACA,eAAA,UAAA,MAAA,KAAA,eAAA,CAAA;AAAA,QACA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,UAAA,EAAA,SAAA,UAAA,KAAA;AACA,QAAA,KAAA,YAAA,SAAA;AACA,YAAA,SAAA,QAAA,cAAA,iBAAA;AACA,UAAA,QAAA;AACA,aAAA,cAAA,UAAA,QAAA;AAAA,UACA,OAAA,MAAA;AACA,iBAAA,YAAA;AAAA,UACA;AAAA,UACA,MAAA,MAAA;AACA,iBAAA,YAAA;AAAA,UACA;AAAA,QACA,CAAA;AAAA,MACA;AAAA,IACA;AAEA,QAAA,KAAA,wBAAA,CAAA,KAAA,YAAA;AAIA,WAAA,cAAA,UAAA,QAAA;AAAA,QACA,SAAA,WAAA;AACA,cACA,KAAA,aACA,CAAA,MAAA,SAAA,MAAA,MAAA,KACA,CAAA,QAAA,SAAA,MAAA,MAAA,GACA;AACA,iBAAA,YAAA;AAAA,UACA;AAAA,QACA;AAAA,QAEA,MAAA,MAAA;AACA,eAAA,YAAA;AAAA,QACA;AAAA,MACA,CAAA;AAAA,IACA;AAEA,QAAA,KAAA,YAAA;AACA,WAAA,YAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,SAAA,YAAA,KAAA;AAAA,EACA;AAAA,EAEA,gBAAA;;AACA,eAAA,gBAAA,mBAAA;AACA,eAAA,gBAAA,mBAAA;AACA,SAAA,kBAAA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,iBAAA;AACA,YAAA,EAAA,SAAA,UAAA,KAAA;AACA,UAAA,KAAA,QAAA,MAAA,gBAAA,GAAA;AACA,mBAAA,MAAA,KAAA,eAAA,GAAA,CAAA;AACA;AAAA,MACA;AAEA,YAAA,SAAA,SAAA,KAAA,MAAA,IACA,KAAA,MAAA,KAAA,UACA,KAAA;AACA,UAAA,QAAA;AAEA,cAAA,KAAA,WAAA,QAAA,UAAA,MAAA;AACA,WAAA,MAAA,QAAA,iBAAA,MAAA,EAAA;AAAA,MACA;AAEA,YAAA,SAAA,WAAA,SAAA,sBAAA;AACA,YAAA,cAAA,OAAA,OAAA,OAAA;AACA,YAAA,aAAA,OAAA,MAAA,OAAA;AACA,YAAA,eAAA,OAAA;AACA,YAAA,gBAAA,OAAA;AACA,YAAA,aAAA,MAAA;AACA,YAAA,cAAA,MAAA;AAEA,UAAA,CAAA,OAAA,SAAA,KAAA,eAAA,MAAA,GAAA,KAAA,CAAA;AACA,UAAA,KAAA,YAAA;AACA,cAAA,WAAA,OAAA;AACA,cAAA,YAAA,OAAA;AACA,YAAA,UAAA,OAAA;AACA,cAAA,aAAA,aAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA,WAAA,UAAA,UAAA;AACA,cAAA,YAAA,aAAA,gBAAA,aAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA,WAAA,UAAA,QAAA;AACA,cAAA,cAAA,YAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA,WAAA,UAAA,SAAA;AACA,cAAA,WAAA,cAAA,eAAA,YAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA;AAEA,YAAA,UAAA,OAAA;AACA,cAAA,YAAA,aAAA,aAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA,WAAA,UAAA,UAAA;AACA,cAAA,aAAA,gBAAA,aAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA,WAAA,UAAA,QAAA;AACA,cAAA,WAAA,cAAA,YAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA,WAAA,UAAA,SAAA;AACA,cAAA,cAAA,eAAA,YAAA;AACA,oBAAA;AAAA,UACA;AAAA,QACA;AAAA,MACA;AAEA,UAAA,OAAA;AACA,UAAA,MAAA;AACA,cAAA;AAAA,aACA;AACA,iBAAA;AACA;AAAA,aACA;AACA,kBAAA;AACA;AAAA,aACA;AACA,kBAAA;AACA;AAAA,aACA;AACA,iBAAA;AACA;AAAA;AAEA,cAAA;AAAA,aACA;AACA,kBAAA,aAAA;AACA;AAAA,aACA;AACA,iBAAA,cAAA;AACA;AAAA;AAEA,UAAA,KAAA,OAAA;AACA,YAAA,UAAA,OAAA;AACA,iBAAA;AAAA,QACA,WAAA,UAAA,UAAA;AACA,iBAAA;AAAA,QACA;AAAA,MACA;AACA,UAAA,UAAA,WAAA,SAAA;AACA,cAAA,gBAAA,QAAA,sBAAA;AACA,gBAAA,cAAA,cAAA;AACA,eAAA,aAAA,cAAA;AAAA,MACA;AACA,YAAA,MAAA,OAAA,GAAA;AACA,YAAA,MAAA,MAAA,GAAA;AAEA,WAAA,MAAA,mBAAA;AAAA,QACA;AAAA,QACA;AAAA,QACA,WAAA,KAAA;AAAA,MACA,CAAA;AAAA,IACA;AAAA,IAEA,UAAA;AACA,UAAA,CAAA,KAAA,UAAA;AACA,aAAA,YAAA,CAAA,KAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA,OAAA;AACA,UAAA,CAAA,KAAA,UAAA;AACA,qBAAA,KAAA,eAAA;AACA,YAAA,OAAA;AACA,eAAA,YAAA;AAAA,QACA,OAAA;AACA,cAAA,KAAA,WAAA;AACA,iBAAA,kBAAA,WAAA,MAAA;AACA,mBAAA,YAAA;AAAA,YACA,GAAA,KAAA,SAAA;AAAA,UACA,OAAA;AACA,iBAAA,YAAA;AAAA,UACA;AAAA,QACA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;AC7UA,IAAIF,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,OAAO;AAAA,IACf,aAAa;AAAA,EACd,GAAE,CAAC,IAAI,WAAW,SAAS,aAAa,GAAG,SAAS,IAAI,GAAG,IAAI,GAAG;AAAA,IACjE,YAAY,CAAC;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,IAAI;AAAA,MACX,YAAY;AAAA,IAClB,CAAK;AAAA,IACD,KAAK;AAAA,IACL,OAAO;AAAA,MACL,cAAc,IAAI;AAAA,MAClB,QAAQ;AAAA,IACT;AAAA,IACD,UAAU;AAAA,MACR,WAAW,MAAM,QAAQ,IAAI,YAAY,IAAI,IAAI,GAAG,IAAI,cAAc,IAAI,IAAI,KAAK,IAAI;AAAA,IACxF;AAAA,IACD,IAAI;AAAA,MACF,UAAU,SAAU,QAAQ;AAC1B,YAAI,MAAM,IAAI,cACV,OAAO,OAAO,QACd,MAAM,KAAK,UAAU,OAAO;AAEhC,YAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,cAAI,MAAM,MACN,MAAM,IAAI,GAAG,KAAK,GAAG;AAEzB,cAAI,KAAK,SAAS;AAChB,kBAAM,KAAM,KAAI,eAAe,IAAI,OAAO,CAAC,GAAG,CAAC;AAAA,UAC3D,OAAiB;AACL,kBAAM,MAAO,KAAI,eAAe,IAAI,MAAM,GAAG,GAAG,EAAE,OAAO,IAAI,MAAM,MAAM,CAAC,CAAC;AAAA,UAC5E;AAAA,QACX,OAAe;AACL,cAAI,eAAe;AAAA,QACpB;AAAA,MACF;AAAA,IACF;AAAA,EACL,GAAK,SAAS,IAAI,YAAY,KAAK,GAAG,IAAI,SAAS,CAAC,IAAI,IAAI,WAAW,SAAS,UAAU,GAAG,SAAS,IAAI,GAAG,IAAI,GAAG;AAAA,IAChH,YAAY,CAAC;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,IAAI;AAAA,MACX,YAAY;AAAA,IAClB,CAAK;AAAA,IACD,KAAK;AAAA,IACL,OAAO;AAAA,MACL,cAAc,IAAI;AAAA,MAClB,QAAQ;AAAA,IACT;AAAA,IACD,UAAU;AAAA,MACR,WAAW,IAAI,GAAG,IAAI,cAAc,IAAI;AAAA,IACzC;AAAA,IACD,IAAI;AAAA,MACF,UAAU,SAAU,QAAQ;AAC1B,YAAI,eAAe;AAAA,MACpB;AAAA,IACF;AAAA,EACF,GAAE,SAAS,IAAI,YAAY,KAAK,GAAG,IAAI,SAAS,CAAC,IAAI,GAAG,SAAS,IAAI,GAAG,IAAI,GAAG;AAAA,IAC9E,YAAY,CAAC;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,IAAI;AAAA,MACX,YAAY;AAAA,IAClB,CAAK;AAAA,IACD,KAAK;AAAA,IACL,OAAO;AAAA,MACL,cAAc,IAAI;AAAA,MAClB,QAAQ,IAAI,WAAW;AAAA,IACxB;AAAA,IACD,UAAU;AAAA,MACR,SAAS,IAAI;AAAA,IACd;AAAA,IACD,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,YAAI,OAAO,OAAO;AAAW;AAC7B,YAAI,eAAe,OAAO,OAAO;AAAA,MAClC;AAAA,IACF;AAAA,EACL,GAAK,SAAS,IAAI,YAAY,KAAK,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC;AACtD;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;AC7DvB,MAAAE,kBAAA;AAAA,EACA,OAAA;AAAA,IACA,MAAA,EAAA,MAAA,QAAA,SAAA,OAAA;AAAA,IACA,OAAA,EAAA,MAAA,CAAA,QAAA,MAAA,GAAA,SAAA,KAAA;AAAA,IACA,IAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,MAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,OAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,UAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,UAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,aAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,cAAA,EAAA,MAAA,QAAA,SAAA,MAAA;AAAA,EAMA;AAAA,EAEA,OAAA;AACA,WAAA;AAAA,MACA,cAAA,KAAA;AAAA,MACA,UAAA;AAAA,MACA,SAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AAAA,IACA,aAAA;AACA,YAAA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,UACA;AACA,aAAA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA,GAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,YAAA;AAGA,YAAA,EAAA,UAAA,cAAA,KAAA;AACA,aAAA;AAAA,IACA;AAAA,IAEA,OAAA;AAEA,YAAA,EAAA,MAAA,KAAA,QAAA,KAAA;AACA,YAAA,YAAA,WAAA,SAAA,OAAA,GAAA,QAAA,SAAA;AACA,aAAA,QAAA,UAAA,GAAA,KAAA,UAAA,GAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,MAAA,QAAA,QAAA;AACA,UAAA,WAAA,QAAA;AACA,aAAA,eAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA,QAAA;AACA,UAAA,WAAA,KAAA,OAAA;AACA,aAAA,MAAA,SAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,QAAA;AACA,WAAA,MAAA,MAAA,MAAA;AAAA,IACA;AAAA,IAEA,OAAA;AACA,WAAA,MAAA,MAAA,KAAA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;ACtHA,IAAIF,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,WAAW,IAAI,GAAG;AAAA,IAC1B,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO;AAAA,MACL,WAAW;AAAA,MACX,QAAQ,IAAI;AAAA,IACb;AAAA,IACD,IAAI;AAAA,MACF,eAAe,SAAU,QAAQ;AAC/B,YAAI,YAAY;AAAA,MACjB;AAAA,IACF;AAAA,EACF,GAAE,WAAW;AAAA,IACZ,YAAY,IAAI;AAAA,IAChB,WAAW,IAAI;AAAA,IACf,UAAU,IAAI;AAAA,IACd,QAAQ,IAAI;AAAA,EAChB,GAAK,KAAK,GAAG,CAAC,GAAG,eAAe,IAAI,GAAG;AAAA,IACnC,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO;AAAA,MACL,cAAc,IAAI;AAAA,IACnB;AAAA,IACD,OAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,SAAS,IAAI;AAAA,MACb,YAAY;AAAA,IACb;AAAA,IACD,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,YAAI,eAAe;AAAA,MACpB;AAAA,MACD,QAAQ,SAAU,QAAQ;AACxB,YAAI,eAAe;AAAA,MACpB;AAAA,MACD,WAAW,IAAI;AAAA,IAChB;AAAA,IACD,MAAM;AAAA,EACP,GAAE,eAAe;AAAA,IAChB,aAAa,IAAI;AAAA,IACjB,UAAU,IAAI;AAAA,EAClB,GAAK,KAAK,CAAC,GAAG,GAAG,YAAY,IAAI,GAAG;AAAA,IAChC,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO;AAAA,MACL,QAAQ;AAAA,MACR,SAAS,IAAI;AAAA,IACd;AAAA,IACD,IAAI;AAAA,MACF,SAAS,IAAI;AAAA,IACd;AAAA,IACD,MAAM;AAAA,EACP,GAAE,YAAY;AAAA,IACb,QAAQ,IAAI;AAAA,IACZ,cAAc,IAAI;AAAA,EACnB,GAAE,KAAK,CAAC,CAAC,GAAG,CAAC;AAChB;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;AChBvB,MAAAE,kBAAA;AAAA,EACA,YAAA,EAAA,SAAA,UAAA,WAAA;AAAA,EAEA,OAAA;AAAA,IACA,OAAA,EAAA,MAAA,MAAA,SAAA,KAAA;AAAA,IACA,YAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,WAAA,EAAA,MAAA,QAAA,SAAA,cAAA;AAAA,IACA,aAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,QAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,YAAA,EAAA,MAAA,QAAA,SAAA,MAAA,eAAA,KAAA;AAAA,IACA,MAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,UAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,QAAA,EAAA,MAAA,CAAA,QAAA,WAAA,GAAA,SAAA,UAAA;AAAA,IACA,cAAA,EAAA,MAAA,UAAA,SAAA,MAAA,MAAA;AAAA,EACA;AAAA,EAEA,OAAA;AACA,WAAA;AAAA,MACA,cAAA,KAAA;AAAA,MACA,WAAA,KAAA;AAAA,MACA,cAAA;AAAA,MACA,SAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AAAA,IACA,UAAA;AACA,aAAA,KAAA,gBAAA,KAAA;AAAA,IACA;AAAA,IAEA,cAAA;AACA,aAAA,OAAA,KAAA,cAAA;AAAA,QACA,QAAA,KAAA;AAAA,QACA,MAAA,KAAA;AAAA,QACA,MAAA;AAAA,MACA,CAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,MAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,eAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA,MAAA;AACA,UAAA,CAAA,SAAA,CAAA,KAAA,OAAA;AACA,aAAA,UAAA;AACA,aAAA,MAAA,SAAA,IAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,KAAA,MAAA;AACA,WAAA,YAAA;AAAA,IACA;AAAA,IAEA,UAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,MAAA,eAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,MAAA,SAAA,UAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,SAAA,IAAA,QAAA,MAAA;AACA,UAAA,KAAA,SAAA;AACA,aAAA,UAAA;AACA,aAAA,MAAA,UAAA,KAAA,YAAA;AAAA,MACA;AAAA,IACA,CAAA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,WAAA,MAAA;AACA,WAAA,eAAA;AACA,WAAA,YAAA;AAAA,IACA;AAAA,IAEA,UAAA,OAAA;;AACA,UAAA,WAAA,MAAA,aAAA,mBAAA,SAAA,iBAAA,KAAA,IAAA;AACA,cAAA,eAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA;AACA,WAAA,MAAA,MAAA,MAAA;AAAA,IACA;AAAA,IAEA,OAAA;AACA,WAAA,MAAA,MAAA,KAAA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;ACpJA,IAAIF,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,WAAW,IAAI,GAAG;AAAA,IAC1B,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO;AAAA,MACL,WAAW;AAAA,MACX,QAAQ,IAAI;AAAA,IACb;AAAA,IACD,IAAI;AAAA,MACF,eAAe,SAAU,QAAQ;AAC/B,YAAI,YAAY;AAAA,MACjB;AAAA,IACF;AAAA,EACF,GAAE,WAAW;AAAA,IACZ,YAAY,IAAI;AAAA,IAChB,WAAW,IAAI;AAAA,IACf,UAAU,IAAI;AAAA,IACd,QAAQ,IAAI;AAAA,EAChB,GAAK,KAAK,GAAG,CAAC,GAAG,eAAe,IAAI,GAAG;AAAA,IACnC,KAAK;AAAA,IACL,aAAa;AAAA,IACb,OAAO;AAAA,MACL,cAAc,IAAI;AAAA,IACnB;AAAA,IACD,OAAO;AAAA,MACL,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,SAAS,IAAI;AAAA,MACb,YAAY;AAAA,IACb;AAAA,IACD,IAAI;AAAA,MACF,SAAS,SAAU,QAAQ;AACzB,YAAI,eAAe;AAAA,MACpB;AAAA,MACD,QAAQ,SAAU,QAAQ;AACxB,YAAI,eAAe;AAAA,MACpB;AAAA,MACD,WAAW,IAAI;AAAA,IAChB;AAAA,IACD,MAAM;AAAA,EACP,GAAE,eAAe;AAAA,IAChB,aAAa,IAAI;AAAA,IACjB,UAAU,IAAI;AAAA,EACf,GAAE,KAAK,CAAC,GAAG,GAAG,OAAO;AAAA,IACpB,aAAa;AAAA,IACb,OAAO;AAAA,MACL,QAAQ;AAAA,IACT;AAAA,IACD,MAAM;AAAA,EACV,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,MAAM;AAAA,IACX,KAAK;AAAA,IACL,aAAa;AAAA,IACb,IAAI;AAAA,MACF,aAAa,SAAU,QAAQ;AAC7B,YAAI,YAAY;AAAA,MACjB;AAAA,IACF;AAAA,EACF,GAAE,IAAI,GAAG,IAAI,SAAU,QAAO;AAC7B,WAAO,CAAC,IAAI,aAAa,SAAQ,CAAC,IAAI,GAAG,MAAM;AAAA,MAC7C,OAAO;AAAA,QACL,UAAU,IAAI,SAAS,SAAQ;AAAA,MAChC;AAAA,MACD,IAAI;AAAA,QACF,SAAS,SAAU,QAAQ;AACzB,cAAI,OAAO,SAAQ;AAAA,QACpB;AAAA,MACF;AAAA,IACF,GAAE,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,QAAQ,SAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,GAAE;AAAA,EACtD,CAAA,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,OAAO;AAAA,IAClB,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,MAAM;AAAA,IACX,KAAK;AAAA,IACL,aAAa;AAAA,IACb,IAAI;AAAA,MACF,aAAa,SAAU,QAAQ;AAC7B,YAAI,YAAY;AAAA,MACjB;AAAA,IACF;AAAA,EACF,GAAE,IAAI,GAAG,IAAI,SAAU,QAAO;AAC7B,WAAO,CAAC,IAAI,eAAe,SAAQ,CAAC,IAAI,GAAG,MAAM;AAAA,MAC/C,OAAO;AAAA,QACL,UAAU,IAAI,WAAW,SAAQ;AAAA,MAClC;AAAA,MACD,IAAI;AAAA,QACF,SAAS,SAAU,QAAQ;AACzB,cAAI,SAAS,SAAQ;AAAA,QACtB;AAAA,MACF;AAAA,IACF,GAAE,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,QAAQ,SAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,GAAE;AAAA,EACtD,CAAA,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,OAAO;AAAA,IAClB,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,MAAM;AAAA,IACX,KAAK;AAAA,IACL,aAAa;AAAA,IACb,IAAI;AAAA,MACF,aAAa,SAAU,QAAQ;AAC7B,YAAI,YAAY;AAAA,MACjB;AAAA,IACF;AAAA,EACF,GAAE,IAAI,GAAG,IAAI,SAAU,QAAO;AAC7B,WAAO,CAAC,IAAI,eAAe,SAAQ,CAAC,IAAI,GAAG,MAAM;AAAA,MAC/C,OAAO;AAAA,QACL,UAAU,IAAI,WAAW,SAAQ;AAAA,MAClC;AAAA,MACD,IAAI;AAAA,QACF,SAAS,SAAU,QAAQ;AACzB,cAAI,SAAS,SAAQ;AAAA,QACtB;AAAA,MACF;AAAA,IACF,GAAE,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,QAAQ,SAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,GAAE;AAAA,EACzD,CAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;AAChB;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;AC4BvB,MAAAE,kBAAA;AAAA,EACA,YAAA,EAAA,SAAA,WAAA;AAAA,EAEA,OAAA;AAAA,IACA,OAAA,EAAA,MAAA,MAAA,SAAA,KAAA;AAAA,IACA,YAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,WAAA,EAAA,MAAA,QAAA,SAAA,cAAA;AAAA,IACA,aAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,MAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,UAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,QAAA,EAAA,MAAA,CAAA,QAAA,WAAA,GAAA,SAAA,UAAA;AAAA,IACA,cAAA,EAAA,MAAA,UAAA,SAAA,MAAA,MAAA;AAAA,IACA,gBAAA,EAAA,MAAA,UAAA,SAAA,MAAA,MAAA;AAAA,IACA,gBAAA,EAAA,MAAA,UAAA,SAAA,MAAA,MAAA;AAAA,EACA;AAAA,EAEA,OAAA;AACA,WAAA;AAAA,MACA,cAAA,KAAA;AAAA,MACA,WAAA,KAAA;AAAA,MACA,cAAA;AAAA,MACA,WAAA;AAAA,MACA,SAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AAAA,IACA,UAAA;AACA,aAAA,KAAA,gBAAA,KAAA;AAAA,IACA;AAAA,IAEA,cAAA;AACA,aAAA,KAAA,eACA,GACA,KAAA,QAAA,KAAA,IAAA,KACA,KAAA,QAAA,KAAA,MAAA,KACA,KAAA,QAAA,KAAA,MAAA,MACA;AAAA,IACA;AAAA,IAEA,cAAA;AACA,aACA,KAAA,gBAIA,SAAA,IAAA,KAAA,GAAA,EAAA,MAAA,GAAA,QAAA,GAAA,QAAA,GAAA;AAAA,IAEA;AAAA,IAEA,MAAA;AAAA,MACA,MAAA;AACA,eAAA,KAAA,YAAA,SAAA;AAAA,MACA;AAAA,MAEA,IAAA,MAAA;AACA,aAAA,QAAA,EAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA;AAAA,MACA,MAAA;AACA,eAAA,KAAA,YAAA,WAAA;AAAA,MACA;AAAA,MAEA,IAAA,QAAA;AACA,aAAA,QAAA,EAAA,QAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA;AAAA,MACA,MAAA;AACA,eAAA,KAAA,YAAA,WAAA;AAAA,MACA;AAAA,MAEA,IAAA,QAAA;AACA,aAAA,QAAA,EAAA,QAAA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,MAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,eAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA,MAAA;AACA,UAAA,CAAA,SAAA,CAAA,KAAA,OAAA;AACA,aAAA,UAAA;AACA,aAAA,MAAA,SAAA,IAAA;AACA,aAAA,UAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA;AAAA,IAEA,WAAA;AAAA,IAEA,KAAA,MAAA;AACA,WAAA,YAAA;AAAA,IACA;AAAA,IAEA,UAAA,QAAA,QAAA;AACA,UAAA,QAAA;AACA,aAAA,gBAAA;AACA,aAAA,UAAA,CAAA;AAAA,MACA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,MAAA,eAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,MAAA,SAAA,UAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,SAAA,IAAA,QAAA,MAAA;AACA,UAAA,KAAA,SAAA;AACA,aAAA,UAAA;AACA,aAAA,MAAA,UAAA,KAAA,YAAA;AAAA,MACA;AAAA,IACA,CAAA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,QAAA,OAAA;AACA,aAAA,OAAA,OAAA,MAAA,EAAA;AAAA,IACA;AAAA,IAEA,QAAA,OAAA;AACA,WAAA,eAAA,SAAA,KAAA,aAAA,KAAA;AAAA,IACA;AAAA,IAEA,gBAAA,QAAA,OAAA;AACA,UAAA,KAAA,aAAA,OAAA;AACA,cAAA,QAAA,IAAA,KAAA;AACA,aAAA,UAAA,MAAA,aAAA,KAAA,MAAA,OAAA,OAAA,QAAA,CAAA,CAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,UAAA,WAAA,KAAA;AACA,YAAA,SAAA,CAAA,KAAA,UAAA;AACA,cAAA,SAAA,KAAA,MAAA;AACA,YAAA,QAAA;AAEA,gBAAA,aAAA,OAAA,eAAA,QAAA,SAAA,SAAA;AACA,mBAAA,QAAA,KAAA,MAAA,QAAA,UAAA,GAAA,QAAA;AAAA,QACA;AAAA,MACA;AACA,WAAA,UAAA,MAAA;AACA,eAAA,QAAA,KAAA,IAAA;AACA,eAAA,UAAA,KAAA,MAAA;AACA,eAAA,UAAA,KAAA,MAAA;AAAA,MACA,CAAA;AAAA,IACA;AAAA,IAEA,UAAA,OAAA;AACA,YAAA,WAAA,CAAA,QAAA,UAAA,QAAA,EAAA,KAAA;AACA,UAAA,UAAA;AACA,cAAA,EAAA,KAAA,KAAA,UAAA,iBAAA,KAAA;AACA,YAAA,KAAA;AACA,gBAAA,QAAA,KAAA,YAAA;AACA,eAAA,YACA,QAAA,IAAA,IACA,QAAA,IAAA,IACA;AAAA,QACA,WAAA,KAAA;AACA,gBAAA,QAAA,KAAA,YAAA;AACA,gBAAA,EAAA,WAAA,KAAA,MAAA,UAAA;AACA,eAAA,YACA,QAAA,IAAA,QAAA,SACA,SAAA,SAAA,QAAA,SACA;AAAA,QACA;AACA,YAAA,OAAA;AACA,eAAA,YAAA;AAAA,QACA;AACA,YAAA,OAAA,OAAA,OAAA;AACA,eAAA,gBAAA,IAAA;AACA,gBAAA,eAAA;AAAA,QACA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA;AACA,WAAA,MAAA,MAAA,MAAA;AAAA,IACA;AAAA,IAEA,OAAA;AACA,WAAA,MAAA,MAAA,KAAA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;AC1VA,IAAIF,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,OAAO;AAAA,IACf,KAAK;AAAA,IACL,aAAa;AAAA,EACjB,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,IACb,OAAO;AAAA,MACL,cAAc,IAAI;AAAA,IACnB;AAAA,EACF,GAAE,CAAC,GAAG,eAAe,IAAI,GAAG;AAAA,IAC3B,KAAK;AAAA,IACL,OAAO;AAAA,MACL,aAAa;AAAA,MACb,UAAU,IAAI,MAAM;AAAA,MACpB,QAAQ,IAAI;AAAA,IACb;AAAA,IACD,IAAI;AAAA,MACF,eAAe,SAAU,QAAQ;AAC/B,YAAI,WAAW;AAAA,MAChB;AAAA,MACD,SAAS,SAAU,QAAQ;AACzB,YAAI,cAAc;AAAA,MACnB;AAAA,MACD,QAAQ,SAAU,QAAQ;AACxB,YAAI,cAAc;AAAA,MACnB;AAAA,IACF;AAAA,IACD,OAAO;AAAA,MACL,OAAO,IAAI;AAAA,MACX,UAAU,SAAU,KAAK;AACvB,YAAI,eAAe;AAAA,MACpB;AAAA,MACD,YAAY;AAAA,IACb;AAAA,EACF,GAAE,eAAe;AAAA,IAChB,YAAY,IAAI;AAAA,IAChB,aAAa,IAAI;AAAA,IACjB,QAAQ,IAAI;AAAA,IACZ,YAAY,IAAI;AAAA,IAChB,UAAU,IAAI;AAAA,EAClB,GAAK,KAAK,CAAC,GAAG,GAAG,eAAe,IAAI,GAAG;AAAA,IACnC,KAAK;AAAA,IACL,OAAO;AAAA,MACL,eAAe;AAAA,MACf,aAAa;AAAA,MACb,UAAU,IAAI,MAAM;AAAA,MACpB,QAAQ,IAAI;AAAA,IACb;AAAA,IACD,IAAI;AAAA,MACF,eAAe,SAAU,QAAQ;AAC/B,YAAI,WAAW;AAAA,MAChB;AAAA,MACD,SAAS,SAAU,QAAQ;AACzB,YAAI,cAAc;AAAA,MACnB;AAAA,MACD,QAAQ,SAAU,QAAQ;AACxB,YAAI,cAAc;AAAA,MACnB;AAAA,IACF;AAAA,IACD,OAAO;AAAA,MACL,OAAO,IAAI;AAAA,MACX,UAAU,SAAU,KAAK;AACvB,YAAI,eAAe;AAAA,MACpB;AAAA,MACD,YAAY;AAAA,IACb;AAAA,EACF,GAAE,eAAe;AAAA,IAChB,YAAY,IAAI;AAAA,IAChB,UAAU,IAAI;AAAA,EACf,GAAE,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;AAClB;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;ACpBvB,MAAAE,kBAAA;AAAA,EACA,YAAA,EAAA,YAAA,WAAA;AAAA,EAEA,OAAA;AAAA,IACA,OAAA,EAAA,MAAA,MAAA,SAAA,KAAA;AAAA,IACA,YAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,aAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,YAAA,EAAA,MAAA,QAAA,SAAA,MAAA,eAAA,KAAA;AAAA,IACA,QAAA,EAAA,MAAA,QAAA,SAAA,QAAA;AAAA,IACA,UAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,EACA;AAAA,EAEA,OAAA;AACA,WAAA;AAAA,MACA,cAAA,KAAA;AAAA,MACA,UAAA;AAAA,MACA,UAAA;AAAA,MACA,aAAA;AAAA,MACA,aAAA;AAAA,MACA,SAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AAAA,IACA,UAAA;AACA,aAAA,KAAA,eAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,MAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,eAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA,MAAA;AACA,UAAA,CAAA,SAAA,CAAA,KAAA,OAAA;AACA,aAAA,UAAA;AACA,aAAA,MAAA,SAAA,IAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,QAAA,QAAA,QAAA;AACA,UAAA,CAAA,WAAA,CAAA,QAAA;AACA,aAAA,MAAA,SAAA,UAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,SAAA,IAAA,QAAA,MAAA;AACA,UAAA,KAAA,SAAA;AACA,aAAA,UAAA;AACA,aAAA,MAAA,UAAA,KAAA,YAAA;AAAA,MACA;AAAA,IACA,CAAA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,QAAA;AACA,WAAA,MAAA,KAAA,MAAA;AAAA,IACA;AAAA,IAEA,OAAA;AACA,WAAA,MAAA,KAAA,KAAA;AACA,WAAA,MAAA,KAAA,KAAA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;AC9HA,IAAIF,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,KAAK;AAAA,IACb,aAAa;AAAA,IACb,OAAO,aAAa,IAAI;AAAA,EAC5B,CAAG;AACH;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;ACGvB,MAAAE,kBAAA;AAAA,EACA,OAAA;AAAA,IACA,MAAA;AAAA,MACA,MAAA;AAAA,MACA,UAAA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;ACtBA,IAAIF,WAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,IAAI,WAAW,IAAI,GAAG,OAAO;AAAA,IAClC,aAAa;AAAA,EACd,GAAE,CAAC,IAAI,YAAY,GAAG,OAAO;AAAA,IAC5B,aAAa;AAAA,EACjB,GAAK,CAAC,IAAI,QAAQ,IAAI,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,KAAK,IAAI,aAAQ,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,GAAG,IAAI,GAAG,QAAQ,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC,GAAG,CAAC,IAAI,IAAI,GAAI,GAAE,GAAG,OAAO;AAAA,IACvJ,aAAa;AAAA,EACd,GAAE,IAAI,GAAG,IAAI,WAAW,SAAU,MAAM;AACvC,WAAO,GAAG,UAAU;AAAA,MAClB,aAAa;AAAA,MACb,OAAO,IAAI,aAAa,IAAI;AAAA,MAC5B,OAAO;AAAA,QACL,YAAY,KAAK;AAAA,MAClB;AAAA,MACD,IAAI;AAAA,QACF,SAAS,SAAU,QAAQ;AACzB,iBAAO,IAAI,YAAY,IAAI;AAAA,QAC5B;AAAA,MACF;AAAA,IACP,GAAO,CAAC,KAAK,OAAO,GAAG,QAAQ,CAAC,IAAI,GAAG,IAAI,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,GAAI,CAAA,CAAC;AAAA,EACpE,CAAA,GAAG,CAAC,CAAC,CAAC,IAAI,IAAI,GAAE;AACnB;AAEA,IAAIC,oBAAkB,CAAA;AACtBD,SAAO,gBAAgB;;AC+BvB,MAAAE,kBAAA;AAAA,EACA,OAAA;AAAA,IACA,OAAA,EAAA,MAAA,QAAA,SAAA,EAAA;AAAA,IACA,MAAA,EAAA,MAAA,QAAA,SAAA,EAAA;AAAA,IACA,UAAA,EAAA,MAAA,QAAA,SAAA,GAAA;AAAA,IACA,WAAA,EAAA,MAAA,SAAA,SAAA,KAAA;AAAA,EACA;AAAA,EAEA,OAAA;AACA,WAAA;AAAA,MACA,WAAA,CAAA;AAAA,MACA,UAAA;AAAA,MACA,UAAA;AAAA,MACA,UAAA;AAAA,MACA,iBAAA,KAAA;AAAA,MACA,aAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AAAA,IACA,QAAA;AACA,aAAA,MAAA,cAAA,KAAA,KAAA,kBAAA;AAAA,IACA;AAAA,IAEA,OAAA;AACA,aAAA,KAAA,IAAA,KAAA,QAAA,KAAA,kBAAA,GAAA,KAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,OAAA;AAAA,IACA,UAAA;AAAA,IACA,UAAA;AAAA,IAEA,KAAA,MAAA;AACA,WAAA,cAAA;AAAA,IACA;AAAA,IAEA,SAAA,UAAA;AACA,WAAA,kBAAA;AAAA,IACA;AAAA,IAEA,gBAAA,iBAAA;AACA,WAAA,WAAA,KAAA,KAAA,KAAA,QAAA,eAAA;AACA,UAAA,KAAA,cAAA,KAAA,UAAA;AACA,aAAA,cAAA,KAAA;AAAA,MACA;AACA,WAAA,gBAAA;AACA,WAAA,MAAA,eAAA,KAAA,MAAA,eAAA;AAAA,IACA;AAAA,IAEA,YAAA,QAAA,QAAA;AACA,UAAA,WAAA,QAAA;AACA,aAAA,gBAAA;AACA,aAAA,MAAA,eAAA,MAAA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,SAAA,cAAA,KAAA;AACA,SAAA,kBAAA,KAAA;AAAA,EACA;AAAA,EAEA,UAAA;AACA,SAAA,gBAAA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,YAAA,MAAA;AACA,UAAA,KAAA,SAAA,CAAA,KAAA,YAAA,KAAA,UAAA,KAAA,aAAA;AACA,aAAA,cAAA,KAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA,MAAA;AACA,YAAA,UAAA;AAAA,QACA,iBAAA,KAAA;AAAA,MACA;AACA,UAAA,KAAA,MAAA;AACA,gBAAA,eAAA,KAAA,UAAA;AAAA,MACA;AACA,aAAA;AAAA,IACA;AAAA,IAEA,kBAAA;AACA,YAAA,EAAA,UAAA,UAAA,OAAA,iBAAA,gBAAA;AACA,YAAA,aAAA,WAAA,WAAA;AACA,YAAA,WAAA,KAAA,WAAA,KAAA,KAAA,QAAA,eAAA;AAEA,UAAA,QAAA;AACA,UAAA,MAAA;AACA,UAAA,YAAA,YAAA;AACA,cAAA;AAAA,MACA,WAAA,eAAA,WAAA,GAAA;AACA,cAAA;AAAA,MACA,WAAA,eAAA,WAAA,UAAA;AACA,cAAA;AACA,gBAAA,WAAA,aAAA;AAAA,MACA,OAAA;AACA,gBAAA,cAAA;AACA,cAAA,cAAA;AAAA,MACA;AAEA,YAAA,YAAA,CAAA;AACA,gBAAA,KAAA;AAAA,QACA,OAAA,cAAA;AAAA,QACA,MAAA;AAAA,QACA,UAAA,eAAA;AAAA,MACA,CAAA;AACA,UAAA,SAAA,GAAA;AACA,kBAAA,KAAA,EAAA,OAAA,GAAA,MAAA,GAAA;AAAA,MACA;AACA,UAAA,QAAA,GAAA;AACA,kBAAA,KAAA;AAAA,UACA,OAAA,KAAA,IAAA,GAAA,cAAA,EAAA;AAAA,UACA,MAAA;AAAA,QACA,CAAA;AAAA,MACA;AACA,eAAA,IAAA,OAAA,KAAA,KAAA,KAAA;AACA,kBAAA,KAAA;AAAA,UACA,OAAA;AAAA,UACA,MAAA;AAAA,UACA,QAAA,MAAA;AAAA,QACA,CAAA;AAAA,MACA;AACA,UAAA,MAAA,WAAA,GAAA;AACA,kBAAA,KAAA;AAAA,UACA,OAAA,KAAA,IAAA,UAAA,cAAA,EAAA;AAAA,UACA,MAAA;AAAA,QACA,CAAA;AAAA,MACA;AACA,UAAA,OAAA,WAAA,GAAA;AACA,kBAAA,KAAA,EAAA,OAAA,UAAA,MAAA,UAAA;AAAA,MACA;AACA,gBAAA,KAAA;AAAA,QACA,OAAA,cAAA;AAAA,QACA,MAAA;AAAA,QACA,UAAA,eAAA;AAAA,MACA,CAAA;AAEA,WAAA,YAAA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;AC3MA,IAAI,SAAS,WAAY;AACvB,MAAI,MAAI;AACR,MAAI,KAAG,IAAI;AACX,MAAI,KAAG,IAAI,MAAM,MAAI;AAErB,SAAO,GAAG,OAAO;AAAA,IACf,aAAa;AAAA,IACb,OAAO,IAAI;AAAA,IACX,OAAO,IAAI;AAAA,EACf,GAAK,CAAC,GAAG,OAAO;AAAA,IACZ,aAAa;AAAA,EACd,GAAE,CAAC,GAAG,SAAS,IAAI,GAAG;AAAA,IACrB,YAAY,CAAC;AAAA,MACX,MAAM;AAAA,MACN,SAAS;AAAA,MACT,OAAO,IAAI;AAAA,MACX,YAAY;AAAA,IAClB,CAAK;AAAA,IACD,KAAK;AAAA,IACL,OAAO;AAAA,MACL,QAAQ;AAAA,IACT;AAAA,IACD,UAAU;AAAA,MACR,WAAW,MAAM,QAAQ,IAAI,OAAO,IAAI,IAAI,GAAG,IAAI,SAAS,IAAI,IAAI,KAAK,IAAI;AAAA,IAC9E;AAAA,IACD,IAAI;AAAA,MACF,UAAU,SAAU,QAAQ;AAC1B,YAAI,MAAM,IAAI,SACV,OAAO,OAAO,QACd,MAAM,KAAK,UAAU,OAAO;AAEhC,YAAI,MAAM,QAAQ,GAAG,GAAG;AACtB,cAAI,MAAM,MACN,MAAM,IAAI,GAAG,KAAK,GAAG;AAEzB,cAAI,KAAK,SAAS;AAChB,kBAAM,KAAM,KAAI,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC;AAAA,UACtD,OAAiB;AACL,kBAAM,MAAO,KAAI,UAAU,IAAI,MAAM,GAAG,GAAG,EAAE,OAAO,IAAI,MAAM,MAAM,CAAC,CAAC;AAAA,UACvE;AAAA,QACX,OAAe;AACL,cAAI,UAAU;AAAA,QACf;AAAA,MACF;AAAA,IACF;AAAA,EACL,GAAK,SAAS,IAAI,YAAY,KAAK,CAAC,GAAG,GAAG,OAAO;AAAA,IAC7C,aAAa;AAAA,EACd,CAAA,GAAG,IAAI,SAAS,GAAG,QAAQ;AAAA,IAC1B,aAAa;AAAA,EACjB,GAAK,CAAC,IAAI,UAAU,IAAI,GAAG,WAAW,WAAY;AAC9C,WAAO,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,OAAO,WAAW,IAAI,CAAC,CAAC;AAAA,EACnD,CAAA,IAAI,IAAI,GAAG,aAAa,WAAY;AACnC,WAAO,CAAC,IAAI,GAAG,IAAI,GAAG,IAAI,OAAO,aAAa,KAAK,CAAC,CAAC;AAAA,EACzD,CAAG,CAAC,GAAG,CAAC,IAAI,IAAI,GAAI,CAAA,CAAC,CAAC,CAAC;AACvB;AAEA,IAAI,kBAAkB,CAAA;AACtB,OAAO,gBAAgB;;AC4CvB,MAAAA,kBAAA;AAAA,EACA,OAAA;AAAA,IACA,OAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,IAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,MAAA,EAAA,MAAA,QAAA,SAAA,KAAA;AAAA,IACA,UAAA,EAAA,MAAA,SAAA,SAAA,MAAA;AAAA,IACA,QAAA,EAAA,MAAA,CAAA,QAAA,OAAA,GAAA,SAAA,MAAA;AAAA,EACA;AAAA,EAEA,OAAA;AACA,WAAA;AAAA,MACA,SAAA,KAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,UAAA;AAAA,IACA,UAAA;AACA,YAAA,EAAA,SAAA,aAAA;AACA,aAAA;AAAA,QACA,gBAAA;AAAA,QACA,iBAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,SAAA;AACA,YAAA,EAAA,QAAA,EAAA,SAAA,cAAA,CAAA,MAAA;AAEA,YAAA,SAAA,KAAA,IAAA,GAAA,mCAAA,QAAA,uCAAA,MAAA;AACA,aAAA;AAAA,QACA,kBAAA,SAAA,GAAA,SAAA,WAAA;AAAA,MACA;AAAA,IACA;AAAA,IAEA,aAAA;AACA,YAAA,EAAA,IAAA,MAAA,UAAA,WAAA;AACA,aAAA,EAAA,IAAA,MAAA,UAAA,GAAA,OAAA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,OAAA;AAAA,IACA,MAAA,OAAA;AACA,WAAA,UAAA;AAAA,IACA;AAAA,IAEA,QAAA,SAAA;AACA,UAAA,YAAA,KAAA,OAAA;AACA,aAAA,MAAA,SAAA,OAAA;AACA,aAAA,MAAA,UAAA,OAAA;AAAA,MACA;AAAA,IACA;AAAA,EACA;AAAA,EAEA,SAAA;AAAA,IACA,QAAA;AACA,WAAA,MAAA,MAAA,MAAA;AAAA,IACA;AAAA,EACA;AACA;;;;;;;;;;;;;AC9IA,MAAA,gBAAA;AAAA,EACA,YAAA;AAAA,EAEA,OAAA;AAAA,IACA,SAAA,EAAA,MAAA,SAAA,SAAA,KAAA;AAAA,EACA;AAAA,EAEA,QAAA,CAAA,eAAA,YAAA,cACA,cACA,QAAA,MAAA,UACA;AAAA,IACA,OAAA,EAAA,MAAA,SAAA;AAAA,IACA,IAAA;AAAA,EACA,IACA,CAAA,GACA,QAAA,QACA;AACA;AAEA,MAAA,WAAA,CAAA,SAAA,UAAA,OAAA,OAAA,QAAA,OAAA,KAAA;AAGA,MAAA,eAAA,aAAA,iBAAA,OAAA,EAAA;AAEA,MAAA,SAAA;AAAA,EACA,WAAA,SAAA;AAIA,eAAA,MAAA,SAAA,SAAA,EAAA,QAAA,OAAA,CAAA,CAAA;AAAA,EACA;AAAA,EAEA,MAAA,SAAA;AACA,UAAA,EAAA,UAAA,iBAAA,OAAA;AACA,aAAA,SAAA;AAAA,MACA;AAAA,MACA,UAAA;AAAA,MACA,YAAA;AAAA,MACA,QAAA;AAAA,IACA,CAAA;AACA,UAAA,EAAA,WAAA,iBAAA,OAAA;AACA,aAAA,SAAA;AAAA,MACA,OAAA;AAAA,MACA,UAAA;AAAA,MACA,YAAA;AAAA,MACA,QAAA;AAAA,IACA,CAAA;AACA,iBAAA,OAAA;AACA,eAAA,MAAA,SAAA,SAAA,EAAA,OAAA,CAAA,CAAA;AAAA,EACA;AAAA,EAEA,MAAA,SAAA;AACA,UAAA,EAAA,WAAA,iBAAA,OAAA;AACA,aAAA,SAAA,EAAA,QAAA;AACA,iBAAA,OAAA;AACA,eAAA,MAAA,SAAA,SAAA,EAAA,QAAA,EAAA,CAAA,CAAA;AAAA,EACA;AACA;;;;;;;;;;;;;;"}