schummar-table 0.37.1 → 0.37.4

package/dist/cjs/index.js

@@ -868,15 +868,15 @@ const thisYear = (delta = 0) => {
 };
 const MS_PER_DAY = 1e3 * 60 * 60 * 24;
 const getCalendarWeek = (date) => {
-  const y = date.getFullYear();
-  const fdoy = new Date(y, 0, 1);
-  const doy = Math.floor((date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) / MS_PER_DAY);
-  const dow = fdoy.getDay();
-  const w = Math.floor((10 + doy - dow) / 7);
-  if (w === 0) {
-    return getCalendarWeek(new Date(y - 1, 11, 31));
+  const endOfWeek = new Date(date.getFullYear(), date.getMonth(), date.getDate() + (7 - (date.getDay() || 7)));
+  const year = endOfWeek.getFullYear();
+  const firstDayOfYear = new Date(year, 0, 1);
+  const dayOfYear = Math.floor((endOfWeek.getTime() - firstDayOfYear.getTime() + (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) / MS_PER_DAY) + 1;
+  const weekOfYear = Math.floor((3 + dayOfYear) / 7);
+  if (weekOfYear === 0) {
+    return getCalendarWeek(new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7)) + 1;
   }
-  return w;
+  return weekOfYear;
 };
 const commonQuickOptions = {
   today: {
@@ -947,7 +947,7 @@ var _ref$d = process.env.NODE_ENV === "production" ? {
 } : {
   name: "kl77zb-DatePicker",
   styles: "display:grid;grid-auto-flow:column;justify-content:center;align-items:baseline;gap:var(--spacing);label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAwaQ","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAubQ","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 var _ref2$4 = process.env.NODE_ENV === "production" ? {
@@ -956,7 +956,7 @@ var _ref2$4 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "7ssa71-DatePicker",
   styles: "display:grid;label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAmcqC","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAkdqC","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 var _ref3$2 = process.env.NODE_ENV === "production" ? {
@@ -965,7 +965,7 @@ var _ref3$2 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "1e48re2-DatePicker",
   styles: "margin:calc(var(--spacing) * 4) 0;display:grid;grid-auto-flow:column;justify-content:space-between;align-items:center;label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAqcY","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAodY","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 var _ref4$2 = process.env.NODE_ENV === "production" ? {
@@ -974,7 +974,7 @@ var _ref4$2 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "avs0ta-DatePicker",
   styles: "transform:rotate3d(0, 0, 1, 180deg);label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AA8c4B","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AA6d4B","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 var _ref5$2 = process.env.NODE_ENV === "production" ? {
@@ -983,7 +983,7 @@ var _ref5$2 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "g57uq1-DatePicker",
   styles: "display:flex;label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAidiB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAgeiB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 var _ref6 = process.env.NODE_ENV === "production" ? {
@@ -992,7 +992,7 @@ var _ref6 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "ru3xfb-DatePicker",
   styles: "justify-self:center;display:grid;grid-template-columns:repeat(8, max-content);label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AA2dY","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AA0eY","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 var _ref7 = process.env.NODE_ENV === "production" ? {
@@ -1001,7 +1001,7 @@ var _ref7 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "5a0dsf-DatePicker",
   styles: "justify-self:center;padding:10px;label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAkfgB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAigBgB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 var _ref8 = process.env.NODE_ENV === "production" ? {
@@ -1010,7 +1010,7 @@ var _ref8 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "1lzq5di-DatePicker",
   styles: "margin-top:var(--spacing);display:grid;grid-auto-flow:column;justify-content:center;label:DatePicker;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AA+lBQ","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAonBQ","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$d
 };
 function DatePicker(props) {
@@ -1223,7 +1223,7 @@ function DatePicker(props) {
           justifySelf: "center",
           padding: 10,
           borderRight: `1px solid ${tableTheme.gray}`
-        }, process.env.NODE_ENV === "production" ? "" : ";label:DatePicker;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAmegB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */"), children: /* @__PURE__ */ jsxRuntime.jsx(Text, { id: "calendarWeek" }) }) : /* @__PURE__ */ jsxRuntime.jsx("div", {}),
+        }, process.env.NODE_ENV === "production" ? "" : ";label:DatePicker;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAkfgB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */"), children: /* @__PURE__ */ jsxRuntime.jsx(Text, { id: "calendarWeek" }) }) : /* @__PURE__ */ jsxRuntime.jsx("div", {}),
         weekDays.map((_v, weekDay) => /* @__PURE__ */ jsxRuntime.jsx("div", { css: _ref7, children: formatWeekday(weekDay) }, weekDay)),
         weeks.map((week, index) => {
           const weekStart = week[0];
@@ -1237,14 +1237,17 @@ function DatePicker(props) {
               cursor: weekDisabled ? void 0 : "pointer",
               font: "inherit",
               borderRight: `1px solid ${tableTheme.gray}`
-            }, process.env.NODE_ENV === "production" ? "" : ";label:DatePicker;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAwgBsB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const y = date.getFullYear();\n  const fdoy = new Date(y, 0, 1);\n  const doy = Math.floor(\n    (date.getTime() - fdoy.getTime() + (date.getTimezoneOffset() - fdoy.getTimezoneOffset())) /\n      MS_PER_DAY,\n  );\n  const dow = fdoy.getDay();\n  const w = Math.floor((10 + doy - dow) / 7);\n\n  if (w === 0) {\n    return getCalendarWeek(new Date(y - 1, 11, 31));\n  }\n\n  return w;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(a: Date | null | DateRange, b: Date | null | DateRange) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<Date>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                    >\n                      {getCalendarWeek((week[0] as DateObj).date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (date.getTime() === hovered?.getTime() ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered ? { min, max: hovered } : { min: hovered, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered(date)}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */"), onClick: () => {
+            }, process.env.NODE_ENV === "production" ? "" : ";label:DatePicker;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx"],"names":[],"mappings":"AAuhBsB","file":"/home/runner/work/schummar-table/schummar-table/src/components/datePicker.tsx","sourcesContent":["import { DateObj, useDayzed } from 'dayzed';\nimport {\n  Fragment,\n  ReactNode,\n  createContext,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport { useTheme } from '../hooks/useTheme';\nimport { defaults } from '../misc/defaults';\nimport { gray } from '../theme/defaultTheme/defaultClasses';\nimport { useCssVariables } from '../theme/useCssVariables';\nimport { DateInput } from './dateInput';\nimport { Text } from './text';\nimport { Interpolation, Theme } from '@emotion/react';\n\nexport type DateRange = { min: Date; max: Date };\n\nexport type DatePickerQuickOption =\n  | 'today'\n  | 'thisWeek'\n  | 'thisMonth'\n  | 'thisYear'\n  | 'lastSevenDays'\n  | 'lastThirtyDays'\n  | { label: ReactNode; value: Date | DateRange | (() => Date | DateRange) }\n  | ((onChange: (value: Date | DateRange | null) => void) => ReactNode);\n\nexport type DatePickerProps = {\n  /** Currently selected day or range of days. */\n  value: Date | DateRange | null;\n  /** Callback for when the day (range) changes. */\n  onChange: (value: Date | DateRange | null) => void;\n  /** Currently visible date. */\n  dateInView?: Date;\n  /** Callback for when the currently visible date changes. */\n  onDateInViewChange?: (value: Date) => void;\n  /** If enabled, ranges can be selected. */\n  rangeSelect?: boolean;\n  /** Which locale to use to render the calendar. */\n  locale?: string;\n  /** Which day of the week should be in the first column. (0=Sunday, 1=Monday, ...)\n   * @default 1\n   */\n  firstDayOfWeek?: 0 | 1 | 2 | 3 | 4 | 5 | 6;\n  /** Which month to show initially */\n  defaultDateInView?: Date;\n  /** Show buttons to quickly select suggested dates or date ranges */\n  quickOptions?: DatePickerQuickOption[];\n  /** Minimum selectable date */\n  /** Date ranges that are visually marked as blocked */\n  blockedRanges?: DateRange[];\n  minDate?: Date;\n  /** Maximum selectable date */\n  maxDate?: Date;\n  /** Whether to show the calendar week in the first column */\n  showCalendarWeek?: boolean;\n};\n\nconst DatePickerContext = createContext<Partial<Omit<DatePickerProps, 'value' | 'onChange'>>>({});\n\nexport function DatePickerProvider({\n  children,\n  ...props\n}: Partial<Omit<DatePickerProps, 'value' | 'onChange'>> & { children?: ReactNode }) {\n  const value = useMemo(() => props, [JSON.stringify(props)]);\n\n  return <DatePickerContext.Provider value={value}>{children}</DatePickerContext.Provider>;\n}\n\nconst weekDays = [0, 1, 2, 3, 4, 5, 6] as const;\n\n/** Rounds a date down to the start of the day. */\nexport const startOfDay = (d: Date) => new Date(d.getFullYear(), d.getMonth(), d.getDate());\n\n/** Rounds a date up to the end of the day. */\nexport const endOfDay = (d: Date) =>\n  new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1, 0, 0, 0, -1);\n\nexport const lastDays = (days: number): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(min.getDate() - days + 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(now),\n  };\n};\n\nexport const today = () => lastDays(1);\n\nexport const thisWeek = (delta = 0, firstDayOfWeek = 1): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n\n  let diff = min.getDay() - firstDayOfWeek;\n  if (diff < 0) {\n    diff += 7;\n  }\n  min.setDate(min.getDate() - diff + delta * 7);\n\n  const max = new Date(min);\n  max.setDate(max.getDate() + 6);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisMonth = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(min.getMonth() + delta);\n  const max = new Date(min);\n  max.setMonth(max.getMonth() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nexport const thisYear = (delta = 0): DateRange => {\n  const now = new Date();\n  const min = new Date(now);\n  min.setDate(1);\n  min.setMonth(0);\n  min.setFullYear(min.getFullYear() + delta);\n  const max = new Date(min);\n  max.setFullYear(max.getFullYear() + 1);\n  max.setDate(max.getDate() - 1);\n\n  return {\n    min: startOfDay(min),\n    max: endOfDay(max),\n  };\n};\n\nconst MS_PER_DAY = 1000 * 60 * 60 * 24;\nexport const getCalendarWeek = (date: Date): number => {\n  // ISO 8601: Week 1 is the week with the first Thursday of the year.\n  // https://en.wikipedia.org/wiki/ISO_week_date\n\n  const endOfWeek = new Date(\n    date.getFullYear(),\n    date.getMonth(),\n    date.getDate() + (7 - (date.getDay() || 7)),\n  );\n\n  const year = endOfWeek.getFullYear();\n  const firstDayOfYear = new Date(year, 0, 1);\n  const dayOfYear =\n    Math.floor(\n      (endOfWeek.getTime() -\n        firstDayOfYear.getTime() +\n        (endOfWeek.getTimezoneOffset() - firstDayOfYear.getTimezoneOffset())) /\n        MS_PER_DAY,\n    ) + 1;\n  const weekOfYear = Math.floor((3 + dayOfYear) / 7);\n\n  if (weekOfYear === 0) {\n    return (\n      getCalendarWeek(\n        new Date(endOfWeek.getFullYear(), endOfWeek.getMonth(), endOfWeek.getDate() - 7),\n      ) + 1\n    );\n  }\n\n  return weekOfYear;\n};\n\nexport const commonQuickOptions = {\n  today: { label: <Text id=\"today\" />, value: today },\n  thisWeek: { label: <Text id=\"thisWeek\" />, value: (props) => thisWeek(0, props.firstDayOfWeek) },\n  thisMonth: { label: <Text id=\"thisMonth\" />, value: () => thisMonth() },\n  thisYear: { label: <Text id=\"thisYear\" />, value: () => thisYear() },\n  lastSevenDays: { label: <Text id=\"lastSevenDays\" />, value: () => lastDays(7) },\n  lastThirtyDays: { label: <Text id=\"lastThirtyDays\" />, value: () => lastDays(30) },\n} satisfies Record<\n  DatePickerQuickOption & string,\n  { label: ReactNode; value: Date | DateRange | ((props: DatePickerProps) => Date | DateRange) }\n>;\n\n/** Returns whether two dates and/or date ranges intersect. Intersection is considered per day. */\nexport function dateIntersect(\n  a: Date | DateRange | null | undefined,\n  b: Date | DateRange | null | undefined,\n) {\n  if (a instanceof Date) {\n    a = { min: a, max: a };\n  }\n  if (b instanceof Date) {\n    b = { min: b, max: b };\n  }\n\n  if (!a?.min || !a.max || !b?.min || !b.max) {\n    return false;\n  }\n\n  return !(endOfDay(a.max) < startOfDay(b.min) || startOfDay(a.min) > endOfDay(b.max));\n}\n\nexport function dateClamp(date: Date, min?: Date, max?: Date) {\n  if (min && date < min) {\n    return min;\n  }\n\n  if (max && date > max) {\n    return max;\n  }\n\n  return date;\n}\n\nfunction getValueForComparison(value?: Date | DateRange | null) {\n  if (!value) {\n    return value;\n  }\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n  return `${value.min?.getTime()}-${value.max?.getTime()}`;\n}\n\nexport function DatePicker(props: DatePickerProps) {\n  const context = useContext(DatePickerContext);\n\n  const {\n    value,\n    rangeSelect,\n    locale,\n    firstDayOfWeek = 1,\n    defaultDateInView,\n    quickOptions = ['today', 'thisWeek'],\n    minDate,\n    maxDate,\n    showCalendarWeek,\n    blockedRanges = [],\n  } = defaults<DatePickerProps>(props, context);\n\n  function onChange(value: Date | DateRange | null) {\n    if (value instanceof Date) {\n      value = dateClamp(value, minDate, maxDate);\n    } else if (value) {\n      value = {\n        min: dateClamp(value.min, minDate, maxDate),\n        max: dateClamp(value.max, minDate, maxDate),\n      };\n    }\n\n    props.onChange(value);\n  }\n\n  const Button = useTheme((t) => t.components.Button);\n  const IconButton = useTheme((t) => t.components.IconButton);\n  const ChevronRight = useTheme((t) => t.icons.ChevronRight);\n  const cssVariables = useCssVariables();\n  function getDayCssStyles({\n    disabled,\n    prevMonth,\n    nextMonth,\n    today,\n    blocked,\n    selected,\n    preSelected,\n  }: {\n    disabled?: boolean;\n    prevMonth?: boolean;\n    nextMonth?: boolean;\n    today?: boolean;\n    blocked?: boolean;\n    selected?: boolean;\n    preSelected?: boolean;\n  }): Interpolation<Theme> {\n    return [\n      {\n        padding: 10,\n        border: 'none',\n        background: 'transparent',\n        cursor: disabled ? undefined : 'pointer',\n        font: 'inherit',\n      },\n      (prevMonth || nextMonth) && {\n        color: gray,\n      },\n      today && {\n        outline: '1px solid var(--secondaryMain)',\n      },\n      blocked && {\n        background: 'var(--blockedMain)',\n        color: 'var(--blockedContrastText)',\n      },\n      selected && {\n        background: 'var(--primaryMain)',\n        color: 'var(--primaryContrastText)',\n      },\n      blocked &&\n        selected && {\n          position: 'relative',\n          '::before': {\n            content: '\"\"',\n            position: 'absolute',\n            top: 0,\n            right: 0,\n            bottom: 0,\n            left: 0,\n            background: 'var(--blockedMain)',\n            clipPath: 'polygon(0 0, 0 50%, 50% 0)',\n          },\n        },\n      preSelected && {\n        background: 'var(--primaryLight)',\n        color: 'var(--primaryContrastText)',\n      },\n    ];\n  }\n\n  const mountTime = useMemo(() => new Date(), []);\n  const [dirty, setDirty] = useState<Partial<DateRange>>();\n  const [hovered, setHovered] = useState<DateRange>();\n  const [dateInViewLocal, setDateInViewLocal] = useState<Date>(defaultDateInView ?? mountTime);\n  const dateInView = props.dateInView ?? dateInViewLocal;\n\n  function setDateInView(date: Date) {\n    setDateInViewLocal(date);\n    props.onDateInViewChange?.(date);\n  }\n\n  const min = dirty ? dirty.min : value instanceof Date ? value : value?.min;\n  const max = dirty ? dirty.max : value instanceof Date ? value : value?.max;\n\n  const resolvedQuickOptions = [...quickOptions, { label: <Text id=\"reset\" />, value: null }].map(\n    (option, index) => {\n      if (option instanceof Function) {\n        return option((value) => {\n          setDirty(undefined);\n          onChange(value);\n        });\n      }\n\n      const { label, value } = typeof option === 'string' ? commonQuickOptions[option] : option;\n\n      return (\n        <Button\n          key={index}\n          variant=\"text\"\n          type=\"button\"\n          onClick={() => {\n            setDirty(undefined);\n\n            if (value instanceof Function) {\n              onChange(value(props));\n            } else {\n              onChange(value);\n            }\n          }}\n        >\n          {label}\n        </Button>\n      );\n    },\n  );\n\n  const { calendars, getBackProps, getForwardProps, getDateProps } = useDayzed({\n    onDateSelected: () => undefined,\n    firstDayOfWeek,\n    showOutsideDays: true,\n    date: dateInView,\n    onOffsetChanged: (offset) =>\n      setDateInView(new Date(dateInView.getFullYear(), dateInView.getMonth() + offset)),\n    offset: 0,\n    minDate,\n    maxDate,\n  });\n  const now = useMemo(() => startOfDay(new Date()), []);\n\n  const formatWeekday = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { weekday: 'short' });\n    return (weekDay: number) =>\n      format(new Date(Date.UTC(2021, 7, ((weekDay + firstDayOfWeek) % 7) + 1)));\n  }, [locale, firstDayOfWeek]);\n\n  useEffect(\n    () =>\n      setDateInView(\n        value === null ? defaultDateInView ?? mountTime : value instanceof Date ? value : value.max,\n      ),\n    [getValueForComparison(value), getValueForComparison(defaultDateInView), mountTime],\n  );\n\n  useEffect(() => {\n    if (!rangeSelect) {\n      setDirty(undefined);\n    }\n  }, [rangeSelect]);\n\n  function set(min?: Date, max?: Date, edit?: 'min' | 'max') {\n    if (!rangeSelect) {\n      onChange(min ?? null);\n      return;\n    }\n\n    if (min && max && min > max) {\n      if (edit === 'min') {\n        max = min;\n      } else if (edit === 'max') {\n        min = max;\n      } else {\n        [min, max] = [max, min];\n      }\n    }\n\n    if (!min === !max) {\n      setDirty(undefined);\n      onChange(min && max ? { min, max: endOfDay(max) } : null);\n    } else {\n      setDirty({ min, max });\n    }\n  }\n\n  const formatMonth = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { month: 'long' });\n    return (month: number) => format(new Date(2021, month));\n  }, [locale]);\n\n  const formatYear = useMemo(() => {\n    const { format } = new Intl.DateTimeFormat(locale, { year: 'numeric' });\n    return (year: number) => format(new Date(year, 0, 1));\n  }, [locale]);\n\n  return (\n    <div css={cssVariables}>\n      <div\n        css={{\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n          alignItems: 'baseline',\n          gap: 'var(--spacing)',\n        }}\n      >\n        <DateInput\n          value={min ?? null}\n          onChange={(date) => set(date ?? undefined, max, 'min')}\n          locale={locale}\n        />\n\n        {rangeSelect && (\n          <>\n            {' - '}\n            <DateInput\n              value={max ?? null}\n              onChange={(date) => set(min, date ?? undefined, 'max')}\n              locale={locale}\n            />\n          </>\n        )}\n      </div>\n\n      {calendars.map(({ month, year, weeks }) => (\n        <div key={`${month}${year}`} css={{ display: 'grid' }}>\n          <div\n            css={{\n              margin: 'calc(var(--spacing) * 4) 0',\n              display: 'grid',\n              gridAutoFlow: 'column',\n              justifyContent: 'space-between',\n              alignItems: 'center',\n            }}\n          >\n            <IconButton type=\"button\" {...getBackProps({ calendars })}>\n              <ChevronRight css={{ transform: 'rotate3d(0, 0, 1, 180deg)' }} />\n            </IconButton>\n\n            <div css={{ display: 'flex' }}>\n              {formatMonth(month)} {formatYear(year)}\n            </div>\n\n            <IconButton type=\"button\" {...getForwardProps({ calendars })}>\n              <ChevronRight />\n            </IconButton>\n          </div>\n\n          <div\n            css={{\n              justifySelf: 'center',\n              display: 'grid',\n              gridTemplateColumns: 'repeat(8, max-content)',\n            }}\n          >\n            {showCalendarWeek ? (\n              <div\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                  borderRight: `1px solid ${gray}`,\n                }}\n              >\n                <Text id=\"calendarWeek\" />\n              </div>\n            ) : (\n              <div />\n            )}\n\n            {weekDays.map((_v, weekDay) => (\n              <div\n                key={weekDay}\n                css={{\n                  justifySelf: 'center',\n                  padding: 10,\n                }}\n              >\n                {formatWeekday(weekDay)}\n              </div>\n            ))}\n\n            {weeks.map((week, index) => {\n              const weekStart = week[0] as DateObj;\n              const weekEnd = week[6] as DateObj;\n              const weekDisabled =\n                !rangeSelect ||\n                (minDate && weekEnd.date < minDate) ||\n                (maxDate && weekStart.date > maxDate);\n\n              return (\n                <Fragment key={index}>\n                  {showCalendarWeek ? (\n                    <button\n                      type=\"button\"\n                      css={{\n                        padding: 10,\n                        border: 'none',\n                        background: 'transparent',\n                        cursor: weekDisabled ? undefined : 'pointer',\n                        font: 'inherit',\n                        borderRight: `1px solid ${gray}`,\n                      }}\n                      onClick={() => {\n                        if (weekDisabled) {\n                          return;\n                        }\n\n                        const min = minDate && weekStart.date < minDate ? minDate : weekStart.date;\n                        const max = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;\n                        set(min, max);\n                      }}\n                      onPointerOver={() =>\n                        !weekDisabled && setHovered({ min: weekStart.date, max: weekEnd.date })\n                      }\n                      onPointerOut={() => !weekDisabled && setHovered(undefined)}\n                    >\n                      {getCalendarWeek(weekEnd.date)}\n                    </button>\n                  ) : (\n                    <div />\n                  )}\n\n                  {week.map((dateObject, dayIndex) => {\n                    if (!dateObject) {\n                      return <div key={dayIndex} />;\n                    }\n\n                    const { prevMonth, nextMonth, date } = dateObject;\n                    const today = startOfDay(date).getTime() === now.getTime();\n                    const disabled = (minDate && date < minDate) || (maxDate && date > maxDate);\n\n                    const selected =\n                      date.getTime() === min?.getTime() ||\n                      (min && max && dateIntersect(date, { min, max }));\n                    const preSelected =\n                      !selected &&\n                      !disabled &&\n                      (dateIntersect(date, hovered) ||\n                        (min &&\n                          !max &&\n                          hovered &&\n                          dateIntersect(\n                            date,\n                            min <= hovered.min\n                              ? { min, max: hovered.min }\n                              : { min: hovered.max, max: min },\n                          )));\n                    const blocked = blockedRanges.some((range) => dateIntersect(date, range));\n\n                    return (\n                      <button\n                        type=\"button\"\n                        key={`${index}-${dayIndex}`}\n                        css={getDayCssStyles({\n                          disabled,\n                          prevMonth,\n                          nextMonth,\n                          today,\n                          blocked,\n                          selected,\n                          preSelected,\n                        })}\n                        {...getDateProps({ dateObj: dateObject })}\n                        onClick={() => {\n                          if (dirty) {\n                            if (min) set(min, date);\n                            else set(date, max);\n                          } else {\n                            set(date);\n                          }\n                        }}\n                        onPointerOver={() => setHovered({ min: date, max: date })}\n                        onPointerOut={() => setHovered(undefined)}\n                        disabled={disabled}\n                      >\n                        {date.getDate()}\n                      </button>\n                    );\n                  })}\n                </Fragment>\n              );\n            })}\n          </div>\n        </div>\n      ))}\n\n      <div\n        css={{\n          marginTop: 'var(--spacing)',\n          display: 'grid',\n          gridAutoFlow: 'column',\n          justifyContent: 'center',\n        }}\n      >\n        {resolvedQuickOptions}\n      </div>\n    </div>\n  );\n}\n"]} */"), onClick: () => {
               if (weekDisabled) {
                 return;
               }
               const min2 = minDate && weekStart.date < minDate ? minDate : weekStart.date;
               const max2 = maxDate && weekEnd.date > maxDate ? maxDate : weekEnd.date;
               set(min2, max2);
-            }, children: getCalendarWeek(week[0].date) }) : /* @__PURE__ */ jsxRuntime.jsx("div", {}),
+            }, onPointerOver: () => !weekDisabled && setHovered({
+              min: weekStart.date,
+              max: weekEnd.date
+            }), onPointerOut: () => !weekDisabled && setHovered(void 0), children: getCalendarWeek(weekEnd.date) }) : /* @__PURE__ */ jsxRuntime.jsx("div", {}),
             week.map((dateObject, dayIndex) => {
               if (!dateObject) {
                 return /* @__PURE__ */ jsxRuntime.jsx("div", {}, dayIndex);
@@ -1260,11 +1263,11 @@ function DatePicker(props) {
                 min,
                 max
               });
-              const preSelected = !selected && !disabled && (date.getTime() === (hovered == null ? void 0 : hovered.getTime()) || min && !max && hovered && dateIntersect(date, min <= hovered ? {
+              const preSelected = !selected && !disabled && (dateIntersect(date, hovered) || min && !max && hovered && dateIntersect(date, min <= hovered.min ? {
                 min,
-                max: hovered
+                max: hovered.min
               } : {
-                min: hovered,
+                min: hovered.max,
                 max: min
               }));
               const blocked = blockedRanges.some((range) => dateIntersect(date, range));
@@ -1287,7 +1290,10 @@ function DatePicker(props) {
                 } else {
                   set(date);
                 }
-              }, onPointerOver: () => setHovered(date), onPointerOut: () => setHovered(void 0), disabled, children: date.getDate() }, `${index}-${dayIndex}`);
+              }, onPointerOver: () => setHovered({
+                min: date,
+                max: date
+              }), onPointerOut: () => setHovered(void 0), disabled, children: date.getDate() }, `${index}-${dayIndex}`);
             })
           ] }, index);
         })
@@ -2569,7 +2575,7 @@ var _ref$6 = process.env.NODE_ENV === "production" ? {
 } : {
   name: "lhgk4n-ColumnHeader",
   styles: "flex:1;label:ColumnHeader;",
-  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx"],"names":[],"mappings":"AAwNW","file":"/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx","sourcesContent":["import { castDraft } from 'immer';\nimport type React from 'react';\nimport { useEffect, useRef } from 'react';\nimport { StoreScope } from 'schummar-state/react';\nimport { useColumnContext, useTableContext } from '../misc/tableContext';\nimport { useTheme } from '../hooks/useTheme';\nimport { cx } from '../misc/helpers';\nimport { defaultClasses } from '../theme/defaultTheme/defaultClasses';\nimport type { Id } from '../types';\nimport { FilterControl } from './filterControl';\nimport { ResizeHandle } from './resizeHandle';\nimport { SortComponent } from './sortComponent';\n\nexport const ColumnHeaderContext = new StoreScope({\n  items: new Map<Id, HTMLDivElement>(),\n});\n\nexport function ColumnHeader() {\n  const ref = useRef<HTMLDivElement>(null);\n  const columnId = useColumnContext();\n  const table = useTableContext();\n  const enabled = table.useState((state) => state.props.enableColumnReorder);\n  const columnStyleOverride = table.useState((state) => state.columnStyleOverride.get(columnId), {\n    throttle: 16,\n  });\n  const stickyHeader = table.useState((state) => state.props.stickyHeader);\n  const classes = useTheme((theme) => theme.classes?.headerCell);\n  const styles = useTheme((theme) => theme.styles?.headerCell);\n\n  const { header, columnClasses, columnStyles } = table.useState((state) => {\n    const column = state.activeColumns.find((column) => column.id === columnId);\n    return {\n      header: column?.header,\n      columnClasses: column?.classes?.headerCell,\n      columnStyles: column?.styles?.headerCell,\n    };\n  });\n\n  const store = ColumnHeaderContext.useStore();\n  const draggingStart = useRef<{ mouseX: number; bounds: DOMRect }>();\n  const clone = useRef<HTMLDivElement>();\n\n  // Track each headers div in a store\n  useEffect(() => {\n    const div = ref.current;\n    if (!div) return;\n\n    store.update((state) => {\n      state.items.set(columnId, castDraft(div));\n    });\n\n    return () => {\n      store.update((state) => {\n        state.items.delete(columnId);\n      });\n    };\n  }, [store, columnId]);\n\n  // Calculate which index the current header would get, given the current offset\n  function calcTargetIndex(offsetLeft: number) {\n    const cols = table\n      .getState()\n      .columnOrder.map((id) => ({ id, div: store.getState().items.get(id) }));\n\n    const otherCols = cols.filter((col) => col.id !== columnId);\n\n    const firstOffsetleft = cols.find((col) => col.div)?.div?.offsetLeft ?? 0;\n\n    let sum = 0;\n    const targetIndex = otherCols.findIndex((col) => {\n      const width = col.div?.offsetWidth ?? 0;\n      if (sum + width / 2 > offsetLeft - firstOffsetleft) return true;\n      sum += width;\n      return false;\n    });\n\n    return targetIndex === -1 ? otherCols.length : targetIndex;\n  }\n\n  // When starting clicking: Record initial mouse and div's bounds\n  function onPointerDown(event: React.PointerEvent) {\n    const div = ref.current;\n    if (!div) return;\n    draggingStart.current = { mouseX: event.clientX, bounds: div.getBoundingClientRect() };\n  }\n\n  // When mouse moves while clicked: Calculate transforms\n  function onPointerMove(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (\n        !div ||\n        draggingStart.current === undefined ||\n        Math.abs(event.clientX - draggingStart.current.mouseX) < 5\n      )\n        return;\n\n      event.stopPropagation();\n      div.setPointerCapture(event.pointerId);\n\n      // Create clone of header div to move around with mouse\n      if (!clone.current) {\n        clone.current = div.cloneNode(true) as HTMLDivElement;\n        document.body.append(clone.current);\n\n        for (const [key, value] of Object.entries(getComputedStyle(div))) {\n          try {\n            clone.current.style[key as any] = value;\n          } catch {\n            // ignore\n          }\n        }\n\n        Object.assign(clone.current.style, {\n          pointerEvents: 'none',\n          position: 'fixed',\n          boxShadow:\n            '0px 5px 5px -3px rgb(0 0 0 / 20%), 0px 8px 10px 1px rgb(0 0 0 / 14%), 0px 3px 14px 2px rgb(0 0 0 / 12%)',\n          left: `${draggingStart.current.bounds.left}px`,\n          top: `${draggingStart.current.bounds.top}px`,\n        });\n\n        div.style.color = 'rgba(0, 0, 0, 0.2)';\n      }\n\n      // Update clone's position each time\n      clone.current.style.left = `${\n        draggingStart.current.bounds.left + event.clientX - draggingStart.current.mouseX\n      }px`;\n\n      // Calculate target index\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      // Apply transforms to each column\n      const columns = table.getState().columnOrder.map((id, index) => ({\n        id,\n        index,\n        width: store.getState().items.get(id)?.offsetWidth ?? 0,\n      }));\n\n      state.columnOrder.forEach((id, i) => {\n        let offset = 0;\n        if (i === index) {\n          // Current column: Move to target pos\n          if (targetIndex > index) {\n            offset = columns\n              .slice(index + 1, targetIndex + 1)\n              .reduce((sum, col) => sum + col.width, 0);\n          } else if (targetIndex < index) {\n            offset = -columns.slice(targetIndex, index).reduce((sum, col) => sum + col.width, 0);\n          }\n        } else if (i >= targetIndex && i < index) {\n          // Left columns: Move right to make room if needed\n          offset = div.offsetWidth;\n        } else if (i > index && i <= targetIndex) {\n          // Right columns: Move left to make room if needed\n          offset = -div.offsetWidth;\n        }\n\n        state.columnStyleOverride.set(id, {\n          transition: 'transform 500ms',\n          transform: `translate3d(${offset}px, 0, 0)`,\n          zIndex: i === index ? 1 : undefined,\n        });\n      });\n    });\n  }\n\n  // When releasing mouse: Reset draggin state and apply column move\n  function onPointerUp(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (!div || draggingStart.current === undefined) return;\n\n      // Apply column move\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      state.columnOrder.splice(index, 1);\n      state.columnOrder.splice(targetIndex, 0, columnId);\n\n      // Cleanup\n      clone.current?.remove();\n      div.style.color = '';\n      state.columnStyleOverride.clear();\n      draggingStart.current = undefined;\n      clone.current = undefined;\n    });\n  }\n\n  return (\n    <div\n      ref={ref}\n      className={cx(classes, columnClasses)}\n      css={[\n        {\n          position: 'relative',\n          userSelect: 'none',\n        },\n        defaultClasses.headerCell,\n        styles,\n        columnStyles,\n        stickyHeader && defaultClasses.sticky,\n        stickyHeader instanceof Object && stickyHeader,\n      ]}\n      style={columnStyleOverride}\n      onPointerDown={enabled ? onPointerDown : undefined}\n      onPointerMove={enabled ? onPointerMove : undefined}\n      onPointerUp={enabled ? onPointerUp : undefined}\n    >\n      <SortComponent>{header}</SortComponent>\n      <div css={{ flex: 1 }} />\n      <FilterControl />\n      <ResizeHandle />\n    </div>\n  );\n}\n"]} */",
+  map: "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx"],"names":[],"mappings":"AAwNW","file":"/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx","sourcesContent":["import { castDraft } from 'immer';\nimport type React from 'react';\nimport { useEffect, useRef } from 'react';\nimport { StoreScope } from 'schummar-state/react';\nimport { useColumnContext, useTableContext } from '../misc/tableContext';\nimport { useTheme } from '../hooks/useTheme';\nimport { cx } from '../misc/helpers';\nimport { defaultClasses } from '../theme/defaultTheme/defaultClasses';\nimport type { Id } from '../types';\nimport { FilterControl } from './filterControl';\nimport { ResizeHandle } from './resizeHandle';\nimport { SortComponent } from './sortComponent';\n\nexport const ColumnHeaderContext = new StoreScope({\n  items: new Map<Id, HTMLDivElement>(),\n});\n\nexport function ColumnHeader() {\n  const ref = useRef<HTMLDivElement>(null);\n  const columnId = useColumnContext();\n  const table = useTableContext();\n  const enabled = table.useState((state) => state.props.enableColumnReorder);\n  const columnStyleOverride = table.useState((state) => state.columnStyleOverride.get(columnId), {\n    throttle: 16,\n  });\n  const stickyHeader = table.useState((state) => state.props.stickyHeader);\n  const classes = useTheme((theme) => theme.classes?.headerCell);\n  const styles = useTheme((theme) => theme.styles?.headerCell);\n\n  const { header, columnClasses, columnStyles } = table.useState((state) => {\n    const column = state.activeColumns.find((column) => column.id === columnId);\n    return {\n      header: column?.header,\n      columnClasses: column?.classes?.headerCell,\n      columnStyles: column?.styles?.headerCell,\n    };\n  });\n\n  const store = ColumnHeaderContext.useStore();\n  const draggingStart = useRef<{ mouseX: number; bounds: DOMRect }>();\n  const clone = useRef<HTMLDivElement>();\n\n  // Track each headers div in a store\n  useEffect(() => {\n    const div = ref.current;\n    if (!div) return;\n\n    store.update((state) => {\n      state.items.set(columnId, castDraft(div));\n    });\n\n    return () => {\n      store.update((state) => {\n        state.items.delete(columnId);\n      });\n    };\n  }, [store, columnId]);\n\n  // Calculate which index the current header would get, given the current offset\n  function calcTargetIndex(offsetLeft: number) {\n    const cols = table\n      .getState()\n      .columnOrder.map((id) => ({ id, div: store.getState().items.get(id) }));\n\n    const otherCols = cols.filter((col) => col.id !== columnId);\n\n    const firstOffsetleft = cols.find((col) => col.div)?.div?.offsetLeft ?? 0;\n\n    let sum = 0;\n    const targetIndex = otherCols.findIndex((col) => {\n      const width = col.div?.offsetWidth ?? 0;\n      if (sum + width / 2 > offsetLeft - firstOffsetleft) return true;\n      sum += width;\n      return false;\n    });\n\n    return targetIndex === -1 ? otherCols.length : targetIndex;\n  }\n\n  // When starting clicking: Record initial mouse and div's bounds\n  function onPointerDown(event: React.PointerEvent) {\n    const div = ref.current;\n    if (!div) return;\n    draggingStart.current = { mouseX: event.clientX, bounds: div.getBoundingClientRect() };\n  }\n\n  // When mouse moves while clicked: Calculate transforms\n  function onPointerMove(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (\n        !div ||\n        draggingStart.current === undefined ||\n        Math.abs(event.clientX - draggingStart.current.mouseX) < 5\n      )\n        return;\n\n      event.stopPropagation();\n      div.setPointerCapture(event.pointerId);\n\n      // Create clone of header div to move around with mouse\n      if (!clone.current) {\n        clone.current = div.cloneNode(true) as HTMLDivElement;\n        document.body.append(clone.current);\n\n        for (const [key, value] of Object.entries(getComputedStyle(div))) {\n          try {\n            clone.current.style[key as any] = value;\n          } catch {\n            // ignore\n          }\n        }\n\n        Object.assign(clone.current.style, {\n          pointerEvents: 'none',\n          position: 'fixed',\n          boxShadow:\n            '0px 5px 5px -3px rgb(0 0 0 / 20%), 0px 8px 10px 1px rgb(0 0 0 / 14%), 0px 3px 14px 2px rgb(0 0 0 / 12%)',\n          left: `${draggingStart.current.bounds.left}px`,\n          top: `${draggingStart.current.bounds.top}px`,\n        });\n\n        div.style.color = 'rgba(0, 0, 0, 0.2)';\n      }\n\n      // Update clone's position each time\n      clone.current.style.left = `${\n        draggingStart.current.bounds.left + event.clientX - draggingStart.current.mouseX\n      }px`;\n\n      // Calculate target index\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      // Apply transforms to each column\n      const columns = table.getState().columnOrder.map((id, index) => ({\n        id,\n        index,\n        width: store.getState().items.get(id)?.offsetWidth ?? 0,\n      }));\n\n      state.columnOrder.forEach((id, i) => {\n        let offset = 0;\n        if (i === index) {\n          // Current column: Move to target pos\n          if (targetIndex > index) {\n            offset = columns\n              .slice(index + 1, targetIndex + 1)\n              .reduce((sum, col) => sum + col.width, 0);\n          } else if (targetIndex < index) {\n            offset = -columns.slice(targetIndex, index).reduce((sum, col) => sum + col.width, 0);\n          }\n        } else if (i >= targetIndex && i < index) {\n          // Left columns: Move right to make room if needed\n          offset = div.offsetWidth;\n        } else if (i > index && i <= targetIndex) {\n          // Right columns: Move left to make room if needed\n          offset = -div.offsetWidth;\n        }\n\n        state.columnStyleOverride.set(id, {\n          transition: 'transform 500ms',\n          transform: `translate3d(${offset}px, 0, 0)`,\n          zIndex: i === index ? 1 : undefined,\n        });\n      });\n    });\n  }\n\n  // When releasing mouse: Reset draggin state and apply column move\n  function onPointerUp(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (!div || draggingStart.current === undefined) return;\n\n      // Apply column move\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      state.columnOrder.splice(index, 1);\n      state.columnOrder.splice(targetIndex, 0, columnId);\n\n      // Cleanup\n      clone.current?.remove();\n      div.style.color = '';\n      state.columnStyleOverride.clear();\n      draggingStart.current = undefined;\n      clone.current = undefined;\n    });\n  }\n\n  return (\n    <div\n      ref={ref}\n      className={cx(classes, columnClasses)}\n      css={[\n        defaultClasses.headerCell,\n        {\n          position: 'relative',\n          userSelect: 'none',\n        },\n        stickyHeader && defaultClasses.sticky,\n        stickyHeader instanceof Object && stickyHeader,\n        styles,\n        columnStyles,\n      ]}\n      style={columnStyleOverride}\n      onPointerDown={enabled ? onPointerDown : undefined}\n      onPointerMove={enabled ? onPointerMove : undefined}\n      onPointerUp={enabled ? onPointerUp : undefined}\n    >\n      <SortComponent>{header}</SortComponent>\n      <div css={{ flex: 1 }} />\n      <FilterControl />\n      <ResizeHandle />\n    </div>\n  );\n}\n"]} */",
   toString: _EMOTION_STRINGIFIED_CSS_ERROR__$6
 };
 function ColumnHeader() {
@@ -2720,7 +2726,7 @@ function ColumnHeader() {
       clone.current = void 0;
     });
   }
-  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref, className: cx(classes, columnClasses), css: ["position:relative;user-select:none;", tableTheme.defaultClasses.headerCell, styles, columnStyles, stickyHeader && tableTheme.defaultClasses.sticky, stickyHeader instanceof Object && stickyHeader, process.env.NODE_ENV === "production" ? "" : ";label:ColumnHeader;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx"],"names":[],"mappings":"AAuMM","file":"/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx","sourcesContent":["import { castDraft } from 'immer';\nimport type React from 'react';\nimport { useEffect, useRef } from 'react';\nimport { StoreScope } from 'schummar-state/react';\nimport { useColumnContext, useTableContext } from '../misc/tableContext';\nimport { useTheme } from '../hooks/useTheme';\nimport { cx } from '../misc/helpers';\nimport { defaultClasses } from '../theme/defaultTheme/defaultClasses';\nimport type { Id } from '../types';\nimport { FilterControl } from './filterControl';\nimport { ResizeHandle } from './resizeHandle';\nimport { SortComponent } from './sortComponent';\n\nexport const ColumnHeaderContext = new StoreScope({\n  items: new Map<Id, HTMLDivElement>(),\n});\n\nexport function ColumnHeader() {\n  const ref = useRef<HTMLDivElement>(null);\n  const columnId = useColumnContext();\n  const table = useTableContext();\n  const enabled = table.useState((state) => state.props.enableColumnReorder);\n  const columnStyleOverride = table.useState((state) => state.columnStyleOverride.get(columnId), {\n    throttle: 16,\n  });\n  const stickyHeader = table.useState((state) => state.props.stickyHeader);\n  const classes = useTheme((theme) => theme.classes?.headerCell);\n  const styles = useTheme((theme) => theme.styles?.headerCell);\n\n  const { header, columnClasses, columnStyles } = table.useState((state) => {\n    const column = state.activeColumns.find((column) => column.id === columnId);\n    return {\n      header: column?.header,\n      columnClasses: column?.classes?.headerCell,\n      columnStyles: column?.styles?.headerCell,\n    };\n  });\n\n  const store = ColumnHeaderContext.useStore();\n  const draggingStart = useRef<{ mouseX: number; bounds: DOMRect }>();\n  const clone = useRef<HTMLDivElement>();\n\n  // Track each headers div in a store\n  useEffect(() => {\n    const div = ref.current;\n    if (!div) return;\n\n    store.update((state) => {\n      state.items.set(columnId, castDraft(div));\n    });\n\n    return () => {\n      store.update((state) => {\n        state.items.delete(columnId);\n      });\n    };\n  }, [store, columnId]);\n\n  // Calculate which index the current header would get, given the current offset\n  function calcTargetIndex(offsetLeft: number) {\n    const cols = table\n      .getState()\n      .columnOrder.map((id) => ({ id, div: store.getState().items.get(id) }));\n\n    const otherCols = cols.filter((col) => col.id !== columnId);\n\n    const firstOffsetleft = cols.find((col) => col.div)?.div?.offsetLeft ?? 0;\n\n    let sum = 0;\n    const targetIndex = otherCols.findIndex((col) => {\n      const width = col.div?.offsetWidth ?? 0;\n      if (sum + width / 2 > offsetLeft - firstOffsetleft) return true;\n      sum += width;\n      return false;\n    });\n\n    return targetIndex === -1 ? otherCols.length : targetIndex;\n  }\n\n  // When starting clicking: Record initial mouse and div's bounds\n  function onPointerDown(event: React.PointerEvent) {\n    const div = ref.current;\n    if (!div) return;\n    draggingStart.current = { mouseX: event.clientX, bounds: div.getBoundingClientRect() };\n  }\n\n  // When mouse moves while clicked: Calculate transforms\n  function onPointerMove(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (\n        !div ||\n        draggingStart.current === undefined ||\n        Math.abs(event.clientX - draggingStart.current.mouseX) < 5\n      )\n        return;\n\n      event.stopPropagation();\n      div.setPointerCapture(event.pointerId);\n\n      // Create clone of header div to move around with mouse\n      if (!clone.current) {\n        clone.current = div.cloneNode(true) as HTMLDivElement;\n        document.body.append(clone.current);\n\n        for (const [key, value] of Object.entries(getComputedStyle(div))) {\n          try {\n            clone.current.style[key as any] = value;\n          } catch {\n            // ignore\n          }\n        }\n\n        Object.assign(clone.current.style, {\n          pointerEvents: 'none',\n          position: 'fixed',\n          boxShadow:\n            '0px 5px 5px -3px rgb(0 0 0 / 20%), 0px 8px 10px 1px rgb(0 0 0 / 14%), 0px 3px 14px 2px rgb(0 0 0 / 12%)',\n          left: `${draggingStart.current.bounds.left}px`,\n          top: `${draggingStart.current.bounds.top}px`,\n        });\n\n        div.style.color = 'rgba(0, 0, 0, 0.2)';\n      }\n\n      // Update clone's position each time\n      clone.current.style.left = `${\n        draggingStart.current.bounds.left + event.clientX - draggingStart.current.mouseX\n      }px`;\n\n      // Calculate target index\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      // Apply transforms to each column\n      const columns = table.getState().columnOrder.map((id, index) => ({\n        id,\n        index,\n        width: store.getState().items.get(id)?.offsetWidth ?? 0,\n      }));\n\n      state.columnOrder.forEach((id, i) => {\n        let offset = 0;\n        if (i === index) {\n          // Current column: Move to target pos\n          if (targetIndex > index) {\n            offset = columns\n              .slice(index + 1, targetIndex + 1)\n              .reduce((sum, col) => sum + col.width, 0);\n          } else if (targetIndex < index) {\n            offset = -columns.slice(targetIndex, index).reduce((sum, col) => sum + col.width, 0);\n          }\n        } else if (i >= targetIndex && i < index) {\n          // Left columns: Move right to make room if needed\n          offset = div.offsetWidth;\n        } else if (i > index && i <= targetIndex) {\n          // Right columns: Move left to make room if needed\n          offset = -div.offsetWidth;\n        }\n\n        state.columnStyleOverride.set(id, {\n          transition: 'transform 500ms',\n          transform: `translate3d(${offset}px, 0, 0)`,\n          zIndex: i === index ? 1 : undefined,\n        });\n      });\n    });\n  }\n\n  // When releasing mouse: Reset draggin state and apply column move\n  function onPointerUp(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (!div || draggingStart.current === undefined) return;\n\n      // Apply column move\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      state.columnOrder.splice(index, 1);\n      state.columnOrder.splice(targetIndex, 0, columnId);\n\n      // Cleanup\n      clone.current?.remove();\n      div.style.color = '';\n      state.columnStyleOverride.clear();\n      draggingStart.current = undefined;\n      clone.current = undefined;\n    });\n  }\n\n  return (\n    <div\n      ref={ref}\n      className={cx(classes, columnClasses)}\n      css={[\n        {\n          position: 'relative',\n          userSelect: 'none',\n        },\n        defaultClasses.headerCell,\n        styles,\n        columnStyles,\n        stickyHeader && defaultClasses.sticky,\n        stickyHeader instanceof Object && stickyHeader,\n      ]}\n      style={columnStyleOverride}\n      onPointerDown={enabled ? onPointerDown : undefined}\n      onPointerMove={enabled ? onPointerMove : undefined}\n      onPointerUp={enabled ? onPointerUp : undefined}\n    >\n      <SortComponent>{header}</SortComponent>\n      <div css={{ flex: 1 }} />\n      <FilterControl />\n      <ResizeHandle />\n    </div>\n  );\n}\n"]} */"], style: columnStyleOverride, onPointerDown: enabled ? onPointerDown : void 0, onPointerMove: enabled ? onPointerMove : void 0, onPointerUp: enabled ? onPointerUp : void 0, children: [
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ref, className: cx(classes, columnClasses), css: [tableTheme.defaultClasses.headerCell, "position:relative;user-select:none;", stickyHeader && tableTheme.defaultClasses.sticky, stickyHeader instanceof Object && stickyHeader, styles, columnStyles, process.env.NODE_ENV === "production" ? "" : ";label:ColumnHeader;", process.env.NODE_ENV === "production" ? "" : "/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx"],"names":[],"mappings":"AAuMM","file":"/home/runner/work/schummar-table/schummar-table/src/components/columnHeader.tsx","sourcesContent":["import { castDraft } from 'immer';\nimport type React from 'react';\nimport { useEffect, useRef } from 'react';\nimport { StoreScope } from 'schummar-state/react';\nimport { useColumnContext, useTableContext } from '../misc/tableContext';\nimport { useTheme } from '../hooks/useTheme';\nimport { cx } from '../misc/helpers';\nimport { defaultClasses } from '../theme/defaultTheme/defaultClasses';\nimport type { Id } from '../types';\nimport { FilterControl } from './filterControl';\nimport { ResizeHandle } from './resizeHandle';\nimport { SortComponent } from './sortComponent';\n\nexport const ColumnHeaderContext = new StoreScope({\n  items: new Map<Id, HTMLDivElement>(),\n});\n\nexport function ColumnHeader() {\n  const ref = useRef<HTMLDivElement>(null);\n  const columnId = useColumnContext();\n  const table = useTableContext();\n  const enabled = table.useState((state) => state.props.enableColumnReorder);\n  const columnStyleOverride = table.useState((state) => state.columnStyleOverride.get(columnId), {\n    throttle: 16,\n  });\n  const stickyHeader = table.useState((state) => state.props.stickyHeader);\n  const classes = useTheme((theme) => theme.classes?.headerCell);\n  const styles = useTheme((theme) => theme.styles?.headerCell);\n\n  const { header, columnClasses, columnStyles } = table.useState((state) => {\n    const column = state.activeColumns.find((column) => column.id === columnId);\n    return {\n      header: column?.header,\n      columnClasses: column?.classes?.headerCell,\n      columnStyles: column?.styles?.headerCell,\n    };\n  });\n\n  const store = ColumnHeaderContext.useStore();\n  const draggingStart = useRef<{ mouseX: number; bounds: DOMRect }>();\n  const clone = useRef<HTMLDivElement>();\n\n  // Track each headers div in a store\n  useEffect(() => {\n    const div = ref.current;\n    if (!div) return;\n\n    store.update((state) => {\n      state.items.set(columnId, castDraft(div));\n    });\n\n    return () => {\n      store.update((state) => {\n        state.items.delete(columnId);\n      });\n    };\n  }, [store, columnId]);\n\n  // Calculate which index the current header would get, given the current offset\n  function calcTargetIndex(offsetLeft: number) {\n    const cols = table\n      .getState()\n      .columnOrder.map((id) => ({ id, div: store.getState().items.get(id) }));\n\n    const otherCols = cols.filter((col) => col.id !== columnId);\n\n    const firstOffsetleft = cols.find((col) => col.div)?.div?.offsetLeft ?? 0;\n\n    let sum = 0;\n    const targetIndex = otherCols.findIndex((col) => {\n      const width = col.div?.offsetWidth ?? 0;\n      if (sum + width / 2 > offsetLeft - firstOffsetleft) return true;\n      sum += width;\n      return false;\n    });\n\n    return targetIndex === -1 ? otherCols.length : targetIndex;\n  }\n\n  // When starting clicking: Record initial mouse and div's bounds\n  function onPointerDown(event: React.PointerEvent) {\n    const div = ref.current;\n    if (!div) return;\n    draggingStart.current = { mouseX: event.clientX, bounds: div.getBoundingClientRect() };\n  }\n\n  // When mouse moves while clicked: Calculate transforms\n  function onPointerMove(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (\n        !div ||\n        draggingStart.current === undefined ||\n        Math.abs(event.clientX - draggingStart.current.mouseX) < 5\n      )\n        return;\n\n      event.stopPropagation();\n      div.setPointerCapture(event.pointerId);\n\n      // Create clone of header div to move around with mouse\n      if (!clone.current) {\n        clone.current = div.cloneNode(true) as HTMLDivElement;\n        document.body.append(clone.current);\n\n        for (const [key, value] of Object.entries(getComputedStyle(div))) {\n          try {\n            clone.current.style[key as any] = value;\n          } catch {\n            // ignore\n          }\n        }\n\n        Object.assign(clone.current.style, {\n          pointerEvents: 'none',\n          position: 'fixed',\n          boxShadow:\n            '0px 5px 5px -3px rgb(0 0 0 / 20%), 0px 8px 10px 1px rgb(0 0 0 / 14%), 0px 3px 14px 2px rgb(0 0 0 / 12%)',\n          left: `${draggingStart.current.bounds.left}px`,\n          top: `${draggingStart.current.bounds.top}px`,\n        });\n\n        div.style.color = 'rgba(0, 0, 0, 0.2)';\n      }\n\n      // Update clone's position each time\n      clone.current.style.left = `${\n        draggingStart.current.bounds.left + event.clientX - draggingStart.current.mouseX\n      }px`;\n\n      // Calculate target index\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      // Apply transforms to each column\n      const columns = table.getState().columnOrder.map((id, index) => ({\n        id,\n        index,\n        width: store.getState().items.get(id)?.offsetWidth ?? 0,\n      }));\n\n      state.columnOrder.forEach((id, i) => {\n        let offset = 0;\n        if (i === index) {\n          // Current column: Move to target pos\n          if (targetIndex > index) {\n            offset = columns\n              .slice(index + 1, targetIndex + 1)\n              .reduce((sum, col) => sum + col.width, 0);\n          } else if (targetIndex < index) {\n            offset = -columns.slice(targetIndex, index).reduce((sum, col) => sum + col.width, 0);\n          }\n        } else if (i >= targetIndex && i < index) {\n          // Left columns: Move right to make room if needed\n          offset = div.offsetWidth;\n        } else if (i > index && i <= targetIndex) {\n          // Right columns: Move left to make room if needed\n          offset = -div.offsetWidth;\n        }\n\n        state.columnStyleOverride.set(id, {\n          transition: 'transform 500ms',\n          transform: `translate3d(${offset}px, 0, 0)`,\n          zIndex: i === index ? 1 : undefined,\n        });\n      });\n    });\n  }\n\n  // When releasing mouse: Reset draggin state and apply column move\n  function onPointerUp(event: React.PointerEvent) {\n    table.update((state) => {\n      const div = ref.current;\n      if (!div || draggingStart.current === undefined) return;\n\n      // Apply column move\n      const index = state.columnOrder.indexOf(columnId);\n      const targetIndex = calcTargetIndex(\n        div.offsetLeft + event.clientX - draggingStart.current.mouseX,\n      );\n\n      state.columnOrder.splice(index, 1);\n      state.columnOrder.splice(targetIndex, 0, columnId);\n\n      // Cleanup\n      clone.current?.remove();\n      div.style.color = '';\n      state.columnStyleOverride.clear();\n      draggingStart.current = undefined;\n      clone.current = undefined;\n    });\n  }\n\n  return (\n    <div\n      ref={ref}\n      className={cx(classes, columnClasses)}\n      css={[\n        defaultClasses.headerCell,\n        {\n          position: 'relative',\n          userSelect: 'none',\n        },\n        stickyHeader && defaultClasses.sticky,\n        stickyHeader instanceof Object && stickyHeader,\n        styles,\n        columnStyles,\n      ]}\n      style={columnStyleOverride}\n      onPointerDown={enabled ? onPointerDown : undefined}\n      onPointerMove={enabled ? onPointerMove : undefined}\n      onPointerUp={enabled ? onPointerUp : undefined}\n    >\n      <SortComponent>{header}</SortComponent>\n      <div css={{ flex: 1 }} />\n      <FilterControl />\n      <ResizeHandle />\n    </div>\n  );\n}\n"]} */"], style: columnStyleOverride, onPointerDown: enabled ? onPointerDown : void 0, onPointerMove: enabled ? onPointerMove : void 0, onPointerUp: enabled ? onPointerUp : void 0, children: [
     /* @__PURE__ */ jsxRuntime.jsx(SortComponent, { children: header }),
     /* @__PURE__ */ jsxRuntime.jsx("div", { css: _ref$6 }),
     /* @__PURE__ */ jsxRuntime.jsx(FilterControl, {}),