import {
  dequal
} from "./chunk-HTVXVXIR.js";
import {
  nanoid
} from "./chunk-HNIHZSAY.js";
import "./chunk-AYNHEKRI.js";
import {
  derived,
  readable,
  readonly,
  writable
} from "./chunk-M5NJIN7F.js";
import "./chunk-X7HCJ7ZS.js";
import {
  SvelteComponentDev,
  action_destroyer,
  add_location,
  add_render_callback,
  append_hydration_dev,
  assign,
  binding_callbacks,
  bubble,
  check_outros,
  children,
  claim_component,
  claim_element,
  claim_space,
  claim_text,
  component_subscribe,
  compute_rest_props,
  createEventDispatcher,
  create_bidirectional_transition,
  create_component,
  create_in_transition,
  create_out_transition,
  create_slot,
  destroy_component,
  detach_dev,
  dispatch_dev,
  element,
  empty,
  exclude_internal_props,
  getContext,
  get_all_dirty_from_scope,
  get_slot_changes,
  get_spread_object,
  get_spread_update,
  get_store_value,
  group_outros,
  init,
  insert_hydration_dev,
  is_function,
  listen_dev,
  mount_component,
  noop,
  onDestroy,
  onMount,
  run_all,
  safe_not_equal,
  setContext,
  set_attributes,
  set_data_dev,
  set_data_maybe_contenteditable_dev,
  set_dynamic_element_data,
  set_style,
  space,
  subscribe,
  text,
  tick,
  transition_in,
  transition_out,
  update_slot_base,
  validate_dynamic_element,
  validate_slots,
  validate_store,
  validate_void_dynamic_element
} from "./chunk-CNW2E2YW.js";
import "./chunk-2GBBIY5G.js";
import {
  __export
} from "./chunk-TNDHKS54.js";

// node_modules/bits-ui/dist/bits/accordion/index.js
var accordion_exports = {};
__export(accordion_exports, {
  Content: () => accordion_content_default,
  Header: () => accordion_header_default,
  Item: () => accordion_item_default,
  Root: () => accordion_default,
  Trigger: () => accordion_trigger_default
});

// node_modules/bits-ui/dist/internal/arrays.js
function arraysAreEqual(arr1, arr2) {
  if (arr1.length !== arr2.length) {
    return false;
  }
  return arr1.every((value, index) => value === arr2[index]);
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/array.js
function back(array, index, increment, loop = true) {
  const previousIndex = index - increment;
  if (previousIndex <= 0) {
    return loop ? array[array.length - 1] : array[0];
  }
  return array[previousIndex];
}
function forward(array, index, increment, loop = true) {
  const nextIndex = index + increment;
  if (nextIndex > array.length - 1) {
    return loop ? array[0] : array[array.length - 1];
  }
  return array[nextIndex];
}
function next(array, index, loop = true) {
  if (index === array.length - 1) {
    return loop ? array[0] : array[index];
  }
  return array[index + 1];
}
function prev(array, currentIndex, loop = true) {
  if (currentIndex <= 0) {
    return loop ? array[array.length - 1] : array[0];
  }
  return array[currentIndex - 1];
}
function last(array) {
  return array[array.length - 1];
}
function wrapArray(array, startIndex) {
  return array.map((_, index) => array[(startIndex + index) % array.length]);
}
function toggle(item, array, compare = dequal) {
  const itemIdx = array.findIndex((innerItem) => compare(innerItem, item));
  if (itemIdx !== -1) {
    array.splice(itemIdx, 1);
  } else {
    array.push(item);
  }
  return array;
}
function chunk(arr, size3) {
  const result = [];
  for (let i = 0; i < arr.length; i += size3) {
    result.push(arr.slice(i, i + size3));
  }
  return result;
}
function isValidIndex(index, arr) {
  return index >= 0 && index < arr.length;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/style.js
function styleToString(style) {
  return Object.keys(style).reduce((str, key) => {
    if (style[key] === void 0)
      return str;
    return str + `${key}:${style[key]};`;
  }, "");
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/attr.js
function disabledAttr(disabled) {
  return disabled ? true : void 0;
}
var hiddenInputAttrs = {
  type: "hidden",
  "aria-hidden": true,
  hidden: true,
  tabIndex: -1,
  style: styleToString({
    position: "absolute",
    opacity: 0,
    "pointer-events": "none",
    margin: 0,
    transform: "translateX(-100%)"
  })
};
function portalAttr(portal) {
  if (portal !== null) {
    return "";
  }
  return void 0;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/store/lightable.js
function lightable(value) {
  function subscribe2(run) {
    run(value);
    return () => {
    };
  }
  return { subscribe: subscribe2 };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/makeElement.js
function getElementByMeltId(id) {
  if (!isBrowser)
    return null;
  const el = document.querySelector(`[data-melt-id="${id}"]`);
  return isHTMLElement(el) ? el : null;
}
var hiddenAction = (obj) => {
  return new Proxy(obj, {
    get(target, prop, receiver) {
      return Reflect.get(target, prop, receiver);
    },
    ownKeys(target) {
      return Reflect.ownKeys(target).filter((key) => key !== "action");
    }
  });
};
var isFunctionWithParams = (fn) => {
  return typeof fn === "function";
};
var emptyMeltElement = makeElement("empty");
function makeElement(name27, args) {
  const { stores, action, returned } = args ?? {};
  const derivedStore = (() => {
    if (stores && returned) {
      return derived(stores, (values) => {
        const result = returned(values);
        if (isFunctionWithParams(result)) {
          const fn = (...args2) => {
            return hiddenAction({
              ...result(...args2),
              [`data-melt-${name27}`]: "",
              action: action ?? noop2
            });
          };
          fn.action = action ?? noop2;
          return fn;
        }
        return hiddenAction({
          ...result,
          [`data-melt-${name27}`]: "",
          action: action ?? noop2
        });
      });
    } else {
      const returnedFn = returned;
      const result = returnedFn == null ? void 0 : returnedFn();
      if (isFunctionWithParams(result)) {
        const resultFn = (...args2) => {
          return hiddenAction({
            ...result(...args2),
            [`data-melt-${name27}`]: "",
            action: action ?? noop2
          });
        };
        resultFn.action = action ?? noop2;
        return lightable(resultFn);
      }
      return lightable(hiddenAction({
        ...result,
        [`data-melt-${name27}`]: "",
        action: action ?? noop2
      }));
    }
  })();
  const actionFn = action ?? (() => {
  });
  actionFn.subscribe = derivedStore.subscribe;
  return actionFn;
}
function makeElementArray(name27, args) {
  const { stores, returned, action } = args;
  const { subscribe: subscribe2 } = derived(stores, (values) => returned(values).map((value) => hiddenAction({
    ...value,
    [`data-melt-${name27}`]: "",
    action: action ?? noop2
  })));
  const actionFn = action ?? (() => {
  });
  actionFn.subscribe = subscribe2;
  return actionFn;
}
function createElHelpers(prefix4) {
  const name27 = (part) => part ? `${prefix4}-${part}` : prefix4;
  const attribute2 = (part) => `data-melt-${prefix4}${part ? `-${part}` : ""}`;
  const selector10 = (part) => `[data-melt-${prefix4}${part ? `-${part}` : ""}]`;
  const getEl = (part) => document.querySelector(selector10(part));
  return {
    name: name27,
    attribute: attribute2,
    selector: selector10,
    getEl
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/is.js
var isBrowser = typeof document !== "undefined";
var isFunction = (v) => typeof v === "function";
function isDocument(element2) {
  return element2 instanceof Document;
}
function isElement(element2) {
  return element2 instanceof Element;
}
function isHTMLElement(element2) {
  return element2 instanceof HTMLElement;
}
function isHTMLInputElement(element2) {
  return element2 instanceof HTMLInputElement;
}
function isHTMLLabelElement(element2) {
  return element2 instanceof HTMLLabelElement;
}
function isHTMLButtonElement(element2) {
  return element2 instanceof HTMLButtonElement;
}
function isElementDisabled(element2) {
  const ariaDisabled = element2.getAttribute("aria-disabled");
  const disabled = element2.getAttribute("disabled");
  const dataDisabled = element2.hasAttribute("data-disabled");
  if (ariaDisabled === "true" || disabled !== null || dataDisabled) {
    return true;
  }
  return false;
}
function isTouch(event) {
  return event.pointerType === "touch";
}
function isFocusVisible(element2) {
  return element2.matches(":focus-visible");
}
function isContentEditable(element2) {
  if (!isHTMLElement(element2))
    return false;
  return element2.isContentEditable;
}
function isNull(value) {
  return value === null;
}
function isNumberString(value) {
  if (isNaN(parseInt(value)))
    return false;
  return true;
}
function isObject(value) {
  return value !== null && typeof value === "object";
}
function isReadable(value) {
  return isObject(value) && "subscribe" in value;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/dom.js
function getTabbableNodes(container) {
  const nodes = [];
  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {
    acceptNode: (node) => {
      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
    }
  });
  while (walker.nextNode()) {
    nodes.push(walker.currentNode);
  }
  return nodes;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/callbacks.js
function executeCallbacks(...callbacks) {
  return (...args) => {
    for (const callback of callbacks) {
      if (typeof callback === "function") {
        callback(...args);
      }
    }
  };
}
function noop2() {
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/event.js
function addEventListener(target, event, handler, options) {
  const events = Array.isArray(event) ? event : [event];
  events.forEach((_event) => target.addEventListener(_event, handler, options));
  return () => {
    events.forEach((_event) => target.removeEventListener(_event, handler, options));
  };
}
function addMeltEventListener(target, event, handler, options) {
  const events = Array.isArray(event) ? event : [event];
  if (typeof handler === "function") {
    const handlerWithMelt = withMelt((_event) => handler(_event));
    events.forEach((_event) => target.addEventListener(_event, handlerWithMelt, options));
    return () => {
      events.forEach((_event) => target.removeEventListener(_event, handlerWithMelt, options));
    };
  }
  return () => noop2();
}
function dispatchMeltEvent(originalEvent) {
  const node = originalEvent.currentTarget;
  if (!isHTMLElement(node))
    return null;
  const customMeltEvent = new CustomEvent(`m-${originalEvent.type}`, {
    detail: {
      originalEvent
    },
    cancelable: true
  });
  node.dispatchEvent(customMeltEvent);
  return customMeltEvent;
}
function withMelt(handler) {
  return (event) => {
    const customEvent = dispatchMeltEvent(event);
    if (customEvent == null ? void 0 : customEvent.defaultPrevented)
      return;
    return handler(event);
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/highlight.js
function addHighlight(element2) {
  element2.setAttribute("data-highlighted", "");
}
function removeHighlight(element2) {
  element2.removeAttribute("data-highlighted");
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/lifecycle.js
var safeOnMount = (fn) => {
  try {
    onMount(fn);
  } catch {
    return fn;
  }
};
var safeOnDestroy = (fn) => {
  try {
    onDestroy(fn);
  } catch {
    return fn;
  }
};

// node_modules/@melt-ui/svelte/dist/internal/helpers/list.js
function getOptions(el) {
  return Array.from(el.querySelectorAll('[role="option"]:not([data-disabled])')).filter((el2) => isHTMLElement(el2));
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/locale.js
function getElemDirection(elem) {
  const style = window.getComputedStyle(elem);
  const direction = style.getPropertyValue("direction");
  return direction;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/object.js
function omit(obj, ...keys) {
  const result = {};
  for (const key of Object.keys(obj)) {
    if (!keys.includes(key)) {
      result[key] = obj[key];
    }
  }
  return result;
}
function stripValues(inputObject, toStrip, recursive) {
  return Object.fromEntries(Object.entries(inputObject).filter(([_, value]) => !dequal(value, toStrip)));
}
function removeUndefined(obj) {
  const result = {};
  for (const key in obj) {
    const value = obj[key];
    if (value !== void 0) {
      result[key] = value;
    }
  }
  return result;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/withGet.js
function withGet(store) {
  return {
    ...store,
    get: () => get_store_value(store)
  };
}
withGet.writable = function(initial) {
  const internal = writable(initial);
  let value = initial;
  return {
    subscribe: internal.subscribe,
    set(newValue) {
      internal.set(newValue);
      value = newValue;
    },
    update(updater) {
      const newValue = updater(value);
      internal.set(newValue);
      value = newValue;
    },
    get() {
      return value;
    }
  };
};
withGet.derived = function(stores, fn) {
  const subscribers = /* @__PURE__ */ new Map();
  const get = () => {
    const values = Array.isArray(stores) ? stores.map((store) => store.get()) : stores.get();
    return fn(values);
  };
  const subscribe2 = (subscriber) => {
    const unsubscribers = [];
    const storesArr = Array.isArray(stores) ? stores : [stores];
    storesArr.forEach((store) => {
      unsubscribers.push(store.subscribe(() => {
        subscriber(get());
      }));
    });
    subscriber(get());
    subscribers.set(subscriber, unsubscribers);
    return () => {
      const unsubscribers2 = subscribers.get(subscriber);
      if (unsubscribers2) {
        for (const unsubscribe of unsubscribers2) {
          unsubscribe();
        }
      }
      subscribers.delete(subscriber);
    };
  };
  return {
    get,
    subscribe: subscribe2
  };
};

// node_modules/@melt-ui/svelte/dist/internal/helpers/overridable.js
var overridable = (_store, onChange) => {
  const store = withGet(_store);
  const update = (updater, sideEffect) => {
    store.update((curr) => {
      const next2 = updater(curr);
      let res = next2;
      if (onChange) {
        res = onChange({ curr, next: next2 });
      }
      sideEffect == null ? void 0 : sideEffect(res);
      return res;
    });
  };
  const set = (curr) => {
    update(() => curr);
  };
  return {
    ...store,
    update,
    set
  };
};

// node_modules/@melt-ui/svelte/dist/internal/helpers/sleep.js
function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/id.js
function generateId() {
  return nanoid(10);
}
function generateIds(args) {
  return args.reduce((acc, curr) => {
    acc[curr] = generateId();
    return acc;
  }, {});
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/keyboard.js
var kbd = {
  ALT: "Alt",
  ARROW_DOWN: "ArrowDown",
  ARROW_LEFT: "ArrowLeft",
  ARROW_RIGHT: "ArrowRight",
  ARROW_UP: "ArrowUp",
  BACKSPACE: "Backspace",
  CAPS_LOCK: "CapsLock",
  CONTROL: "Control",
  DELETE: "Delete",
  END: "End",
  ENTER: "Enter",
  ESCAPE: "Escape",
  F1: "F1",
  F10: "F10",
  F11: "F11",
  F12: "F12",
  F2: "F2",
  F3: "F3",
  F4: "F4",
  F5: "F5",
  F6: "F6",
  F7: "F7",
  F8: "F8",
  F9: "F9",
  HOME: "Home",
  META: "Meta",
  PAGE_DOWN: "PageDown",
  PAGE_UP: "PageUp",
  SHIFT: "Shift",
  SPACE: " ",
  TAB: "Tab",
  CTRL: "Control",
  ASTERISK: "*",
  A: "a",
  P: "p"
};
var FIRST_KEYS = [kbd.ARROW_DOWN, kbd.PAGE_UP, kbd.HOME];
var LAST_KEYS = [kbd.ARROW_UP, kbd.PAGE_DOWN, kbd.END];
var FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
var SELECTION_KEYS = [kbd.ENTER, kbd.SPACE];
var getNextKey = (dir = "ltr", orientation = "horizontal") => {
  return {
    horizontal: dir === "rtl" ? kbd.ARROW_LEFT : kbd.ARROW_RIGHT,
    vertical: kbd.ARROW_DOWN
  }[orientation];
};
var getPrevKey = (dir = "ltr", orientation = "horizontal") => {
  return {
    horizontal: dir === "rtl" ? kbd.ARROW_RIGHT : kbd.ARROW_LEFT,
    vertical: kbd.ARROW_UP
  }[orientation];
};
var getDirectionalKeys = (dir = "ltr", orientation = "horizontal") => {
  return {
    nextKey: getNextKey(dir, orientation),
    prevKey: getPrevKey(dir, orientation)
  };
};

// node_modules/@melt-ui/svelte/dist/internal/helpers/debounce.js
function debounce(fn, wait = 500) {
  let timeout = null;
  return function(...args) {
    const later = () => {
      timeout = null;
      fn(...args);
    };
    timeout && clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/platform.js
var isDom = () => typeof window !== "undefined";
function getPlatform() {
  const agent = navigator.userAgentData;
  return (agent == null ? void 0 : agent.platform) ?? navigator.platform;
}
var pt = (v) => isDom() && v.test(getPlatform().toLowerCase());
var ua = (v) => isDom() && v.test(navigator.userAgent);
var isTouchDevice = () => isDom() && !!navigator.maxTouchPoints;
var isMac = () => pt(/^mac/) && !isTouchDevice();
var isFirefox = () => ua(/firefox\//i);
var isApple = () => pt(/mac|iphone|ipad|ipod/i);
var isIos = () => isApple() && !isMac();

// node_modules/@melt-ui/svelte/dist/internal/helpers/polygon/hull.js
function makeHull(points) {
  const newPoints = points.slice();
  newPoints.sort(POINT_COMPARATOR);
  return makeHullPresorted(newPoints);
}
function makeHullPresorted(points) {
  if (points.length <= 1)
    return points.slice();
  const upperHull = [];
  for (let i = 0; i < points.length; i++) {
    const p = points[i];
    while (upperHull.length >= 2) {
      const q = upperHull[upperHull.length - 1];
      const r = upperHull[upperHull.length - 2];
      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))
        upperHull.pop();
      else
        break;
    }
    upperHull.push(p);
  }
  upperHull.pop();
  const lowerHull = [];
  for (let i = points.length - 1; i >= 0; i--) {
    const p = points[i];
    while (lowerHull.length >= 2) {
      const q = lowerHull[lowerHull.length - 1];
      const r = lowerHull[lowerHull.length - 2];
      if ((q.x - r.x) * (p.y - r.y) >= (q.y - r.y) * (p.x - r.x))
        lowerHull.pop();
      else
        break;
    }
    lowerHull.push(p);
  }
  lowerHull.pop();
  if (upperHull.length == 1 && lowerHull.length == 1 && upperHull[0].x == lowerHull[0].x && upperHull[0].y == lowerHull[0].y)
    return upperHull;
  else
    return upperHull.concat(lowerHull);
}
function POINT_COMPARATOR(a, b) {
  if (a.x < b.x)
    return -1;
  else if (a.x > b.x)
    return 1;
  else if (a.y < b.y)
    return -1;
  else if (a.y > b.y)
    return 1;
  else
    return 0;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/polygon/index.js
function getPointsFromEl(el) {
  const rect = el.getBoundingClientRect();
  return [
    { x: rect.left, y: rect.top },
    { x: rect.right, y: rect.top },
    { x: rect.right, y: rect.bottom },
    { x: rect.left, y: rect.bottom }
  ];
}
function makeHullFromElements(els) {
  const points = els.flatMap((el) => getPointsFromEl(el));
  return makeHull(points);
}
function pointInPolygon(point, polygon) {
  let inside = false;
  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
    const xi = polygon[i].x;
    const yi = polygon[i].y;
    const xj = polygon[j].x;
    const yj = polygon[j].y;
    const intersect = yi > point.y !== yj > point.y && point.x < (xj - xi) * (point.y - yi) / (yj - yi) + xi;
    if (intersect)
      inside = !inside;
  }
  return inside;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/scroll.js
var LOCK_CLASSNAME = "data-melt-scroll-lock";
function assignStyle(el, style) {
  if (!el)
    return;
  const previousStyle = el.style.cssText;
  Object.assign(el.style, style);
  return () => {
    el.style.cssText = previousStyle;
  };
}
function setCSSProperty(el, property, value) {
  if (!el)
    return;
  const previousValue = el.style.getPropertyValue(property);
  el.style.setProperty(property, value);
  return () => {
    if (previousValue) {
      el.style.setProperty(property, previousValue);
    } else {
      el.style.removeProperty(property);
    }
  };
}
function getPaddingProperty(documentElement) {
  const documentLeft = documentElement.getBoundingClientRect().left;
  const scrollbarX = Math.round(documentLeft) + documentElement.scrollLeft;
  return scrollbarX ? "paddingLeft" : "paddingRight";
}
function removeScroll(_document) {
  const doc = _document ?? document;
  const win = doc.defaultView ?? window;
  const { documentElement, body } = doc;
  const locked = body.hasAttribute(LOCK_CLASSNAME);
  if (locked)
    return noop2;
  body.setAttribute(LOCK_CLASSNAME, "");
  const scrollbarWidth = win.innerWidth - documentElement.clientWidth;
  const setScrollbarWidthProperty = () => setCSSProperty(documentElement, "--scrollbar-width", `${scrollbarWidth}px`);
  const paddingProperty = getPaddingProperty(documentElement);
  const scrollbarSidePadding = win.getComputedStyle(body)[paddingProperty];
  const setStyle = () => assignStyle(body, {
    overflow: "hidden",
    [paddingProperty]: `calc(${scrollbarSidePadding} + ${scrollbarWidth}px)`
  });
  const setIOSStyle = () => {
    const { scrollX, scrollY, visualViewport } = win;
    const offsetLeft = (visualViewport == null ? void 0 : visualViewport.offsetLeft) ?? 0;
    const offsetTop = (visualViewport == null ? void 0 : visualViewport.offsetTop) ?? 0;
    const restoreStyle = assignStyle(body, {
      position: "fixed",
      overflow: "hidden",
      top: `${-(scrollY - Math.floor(offsetTop))}px`,
      left: `${-(scrollX - Math.floor(offsetLeft))}px`,
      right: "0",
      [paddingProperty]: `calc(${scrollbarSidePadding} + ${scrollbarWidth}px)`
    });
    return () => {
      restoreStyle == null ? void 0 : restoreStyle();
      win.scrollTo(scrollX, scrollY);
    };
  };
  const cleanups = [setScrollbarWidthProperty(), isIos() ? setIOSStyle() : setStyle()];
  return () => {
    cleanups.forEach((fn) => fn == null ? void 0 : fn());
    body.removeAttribute(LOCK_CLASSNAME);
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/store/derivedVisible.js
function derivedVisible(obj) {
  const { open, forceVisible, activeTrigger } = obj;
  return derived([open, forceVisible, activeTrigger], ([$open, $forceVisible, $activeTrigger]) => ($open || $forceVisible) && $activeTrigger !== null);
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/store/effect.js
function effect(stores, fn) {
  let cb = void 0;
  const destroy = derived(stores, (stores2) => {
    cb == null ? void 0 : cb();
    cb = fn(stores2);
  }).subscribe(noop2);
  const unsub = () => {
    destroy();
    cb == null ? void 0 : cb();
  };
  safeOnDestroy(unsub);
  return unsub;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/store/toWritableStores.js
function toWritableStores(properties) {
  const result = {};
  Object.keys(properties).forEach((key) => {
    const propertyKey = key;
    const value = properties[propertyKey];
    result[propertyKey] = withGet(writable(value));
  });
  return result;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/rovingFocus.js
function handleRovingFocus(nextElement) {
  if (!isBrowser)
    return;
  sleep(1).then(() => {
    const currentFocusedElement = document.activeElement;
    if (!isHTMLElement(currentFocusedElement) || currentFocusedElement === nextElement)
      return;
    currentFocusedElement.tabIndex = -1;
    if (nextElement) {
      nextElement.tabIndex = 0;
      nextElement.focus();
    }
  });
}
function getFocusableElements() {
  return Array.from(document.querySelectorAll('a[href]:not([tabindex="-1"]), button:not([disabled]):not([tabindex="-1"]), input:not([disabled]):not([tabindex="-1"]), select:not([disabled]):not([tabindex="-1"]), textarea:not([disabled]):not([tabindex="-1"]), [tabindex]:not([tabindex="-1"])'));
}
function getNextFocusable(currentElement) {
  const focusableElements = getFocusableElements();
  const currentIndex = focusableElements.indexOf(currentElement);
  const nextIndex = currentIndex + 1;
  const nextElement = focusableElements[nextIndex];
  if (nextIndex < focusableElements.length && isHTMLElement(nextElement)) {
    return nextElement;
  }
  return null;
}
function getPreviousFocusable(currentElement) {
  const focusableElements = getFocusableElements();
  const currentIndex = focusableElements.indexOf(currentElement);
  const previousIndex = currentIndex - 1;
  const prevElement = focusableElements[previousIndex];
  if (previousIndex >= 0 && isHTMLElement(prevElement)) {
    return prevElement;
  }
  return null;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/typeahead.js
var ignoredKeys = /* @__PURE__ */ new Set(["Shift", "Control", "Alt", "Meta", "CapsLock", "NumLock"]);
var defaults = {
  onMatch: handleRovingFocus,
  getCurrentItem: () => document.activeElement
};
function createTypeaheadSearch(args = {}) {
  const withDefaults = { ...defaults, ...args };
  const typed = withGet(writable([]));
  const resetTyped = debounce(() => {
    typed.update(() => []);
  });
  const handleTypeaheadSearch = (key, items) => {
    if (ignoredKeys.has(key))
      return;
    const currentItem = withDefaults.getCurrentItem();
    const $typed = get_store_value(typed);
    if (!Array.isArray($typed)) {
      return;
    }
    $typed.push(key.toLowerCase());
    typed.set($typed);
    const candidateItems = items.filter((item) => {
      if (item.getAttribute("disabled") === "true" || item.getAttribute("aria-disabled") === "true" || item.hasAttribute("data-disabled")) {
        return false;
      }
      return true;
    });
    const isRepeated = $typed.length > 1 && $typed.every((char) => char === $typed[0]);
    const normalizeSearch = isRepeated ? $typed[0] : $typed.join("");
    const currentItemIndex = isHTMLElement(currentItem) ? candidateItems.indexOf(currentItem) : -1;
    let wrappedItems = wrapArray(candidateItems, Math.max(currentItemIndex, 0));
    const excludeCurrentItem = normalizeSearch.length === 1;
    if (excludeCurrentItem) {
      wrappedItems = wrappedItems.filter((v) => v !== currentItem);
    }
    const nextItem = wrappedItems.find((item) => (item == null ? void 0 : item.innerText) && item.innerText.toLowerCase().startsWith(normalizeSearch.toLowerCase()));
    if (isHTMLElement(nextItem) && nextItem !== currentItem) {
      withDefaults.onMatch(nextItem);
    }
    resetTyped();
  };
  return {
    typed,
    resetTyped,
    handleTypeaheadSearch
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/elements.js
function getPortalParent(node) {
  let parent = node.parentElement;
  while (isHTMLElement(parent) && !parent.hasAttribute("data-portal")) {
    parent = parent.parentElement;
  }
  return parent || "body";
}
function getPortalDestination(node, portalProp) {
  if (portalProp !== void 0)
    return portalProp;
  const portalParent = getPortalParent(node);
  if (portalParent === "body")
    return document.body;
  return null;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/ignore.js
function createClickOutsideIgnore(meltId) {
  return (e) => {
    const target = e.target;
    const triggerEl = getElementByMeltId(meltId);
    if (!triggerEl || !isElement(target))
      return false;
    const id = triggerEl.id;
    if (isHTMLLabelElement(target) && id === target.htmlFor) {
      return true;
    }
    if (target.closest(`label[for="${id}"]`)) {
      return true;
    }
    return false;
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/focus.js
async function handleFocus(args) {
  const { prop, defaultEl } = args;
  await Promise.all([sleep(1), tick]);
  if (prop === void 0) {
    defaultEl == null ? void 0 : defaultEl.focus();
    return;
  }
  const returned = isFunction(prop) ? prop(defaultEl) : prop;
  if (typeof returned === "string") {
    const el = document.querySelector(returned);
    if (!isHTMLElement(el))
      return;
    el.focus();
  } else if (isHTMLElement(returned)) {
    returned.focus();
  }
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/math.js
function snapValueToStep(value, min2, max2, step) {
  const remainder = (value - (isNaN(min2) ? 0 : min2)) % step;
  let snappedValue = Math.abs(remainder) * 2 >= step ? value + Math.sign(remainder) * (step - Math.abs(remainder)) : value - remainder;
  if (!isNaN(min2)) {
    if (snappedValue < min2) {
      snappedValue = min2;
    } else if (!isNaN(max2) && snappedValue > max2) {
      snappedValue = min2 + Math.floor((max2 - min2) / step) * step;
    }
  } else if (!isNaN(max2) && snappedValue > max2) {
    snappedValue = Math.floor(max2 / step) * step;
  }
  const string = step.toString();
  const index = string.indexOf(".");
  const precision = index >= 0 ? string.length - index : 0;
  if (precision > 0) {
    const pow = Math.pow(10, precision);
    snappedValue = Math.round(snappedValue * pow) / pow;
  }
  return snappedValue;
}
function clamp(min2, value, max2) {
  return Math.max(min2, Math.min(value, max2));
}

// node_modules/@melt-ui/svelte/dist/builders/accordion/create.js
var { name, selector } = createElHelpers("accordion");
var defaults2 = {
  multiple: false,
  disabled: false,
  forceVisible: false
};
var createAccordion = (props) => {
  const withDefaults = { ...defaults2, ...props };
  const options = toWritableStores(omit(withDefaults, "value", "onValueChange", "defaultValue"));
  const meltIds = generateIds(["root"]);
  const { disabled, forceVisible } = options;
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults == null ? void 0 : withDefaults.onValueChange);
  const isSelected = (key, v) => {
    if (v === void 0)
      return false;
    if (typeof v === "string")
      return v === key;
    return v.includes(key);
  };
  const isSelectedStore = derived(value, ($value) => {
    return (key) => isSelected(key, $value);
  });
  const root = makeElement(name(), {
    returned: () => ({
      "data-melt-id": meltIds.root
    })
  });
  const parseItemProps = (props2) => {
    if (typeof props2 === "string") {
      return { value: props2 };
    } else {
      return props2;
    }
  };
  const parseHeadingProps = (props2) => {
    if (typeof props2 === "number") {
      return { level: props2 };
    } else {
      return props2;
    }
  };
  const item = makeElement(name("item"), {
    stores: value,
    returned: ($value) => {
      return (props2) => {
        const { value: itemValue, disabled: disabled2 } = parseItemProps(props2);
        return {
          "data-state": isSelected(itemValue, $value) ? "open" : "closed",
          "data-disabled": disabledAttr(disabled2)
        };
      };
    }
  });
  const trigger = makeElement(name("trigger"), {
    stores: [value, disabled],
    returned: ([$value, $disabled]) => {
      return (props2) => {
        const { value: itemValue, disabled: disabled2 } = parseItemProps(props2);
        return {
          disabled: disabledAttr($disabled || disabled2),
          "aria-expanded": isSelected(itemValue, $value) ? true : false,
          "aria-disabled": disabled2 ? true : false,
          "data-disabled": disabledAttr(disabled2),
          "data-value": itemValue,
          "data-state": isSelected(itemValue, $value) ? "open" : "closed"
        };
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        const disabled2 = node.dataset.disabled === "true";
        const itemValue = node.dataset.value;
        if (disabled2 || !itemValue)
          return;
        handleValueUpdate(itemValue);
      }), addMeltEventListener(node, "keydown", (e) => {
        if (![kbd.ARROW_DOWN, kbd.ARROW_UP, kbd.HOME, kbd.END].includes(e.key)) {
          return;
        }
        e.preventDefault();
        if (e.key === kbd.SPACE || e.key === kbd.ENTER) {
          const disabled2 = node.dataset.disabled === "true";
          const itemValue = node.dataset.value;
          if (disabled2 || !itemValue)
            return;
          handleValueUpdate(itemValue);
          return;
        }
        const el = e.target;
        const rootEl = getElementByMeltId(meltIds.root);
        if (!rootEl || !isHTMLElement(el))
          return;
        const items = Array.from(rootEl.querySelectorAll(selector("trigger")));
        const candidateItems = items.filter((item2) => {
          if (!isHTMLElement(item2))
            return false;
          return item2.dataset.disabled !== "true";
        });
        if (!candidateItems.length)
          return;
        const elIdx = candidateItems.indexOf(el);
        if (e.key === kbd.ARROW_DOWN) {
          candidateItems[(elIdx + 1) % candidateItems.length].focus();
        }
        if (e.key === kbd.ARROW_UP) {
          candidateItems[(elIdx - 1 + candidateItems.length) % candidateItems.length].focus();
        }
        if (e.key === kbd.HOME) {
          candidateItems[0].focus();
        }
        if (e.key === kbd.END) {
          candidateItems[candidateItems.length - 1].focus();
        }
      }));
      return {
        destroy: unsub
      };
    }
  });
  const content = makeElement(name("content"), {
    stores: [value, disabled, forceVisible],
    returned: ([$value, $disabled, $forceVisible]) => {
      return (props2) => {
        const { value: itemValue } = parseItemProps(props2);
        const isVisible = isSelected(itemValue, $value) || $forceVisible;
        return {
          "data-state": isVisible ? "open" : "closed",
          "data-disabled": disabledAttr($disabled),
          "data-value": itemValue,
          hidden: isVisible ? void 0 : true,
          style: styleToString({
            display: isVisible ? void 0 : "none"
          })
        };
      };
    },
    action: (node) => {
      tick().then(() => {
        const contentId = generateId();
        const triggerId = generateId();
        const parentTrigger = document.querySelector(`${selector("trigger")}, [data-value="${node.dataset.value}"]`);
        if (!isHTMLElement(parentTrigger))
          return;
        node.id = contentId;
        parentTrigger.setAttribute("aria-controls", contentId);
        parentTrigger.id = triggerId;
      });
    }
  });
  const heading = makeElement(name("heading"), {
    returned: () => {
      return (props2) => {
        const { level } = parseHeadingProps(props2);
        return {
          role: "heading",
          "aria-level": level,
          "data-heading-level": level
        };
      };
    }
  });
  function handleValueUpdate(itemValue) {
    value.update(($value) => {
      if ($value === void 0) {
        return withDefaults.multiple ? [itemValue] : itemValue;
      }
      if (Array.isArray($value)) {
        if ($value.includes(itemValue)) {
          return $value.filter((v) => v !== itemValue);
        }
        $value.push(itemValue);
        return $value;
      }
      return $value === itemValue ? void 0 : itemValue;
    });
  }
  return {
    ids: meltIds,
    elements: {
      root,
      item,
      trigger,
      content,
      heading
    },
    states: {
      value
    },
    helpers: {
      isSelected: isSelectedStore
    },
    options
  };
};

// node_modules/@melt-ui/svelte/dist/builders/avatar/create.js
var defaults3 = {
  src: "",
  delayMs: 0,
  onLoadingStatusChange: void 0
};
var createAvatar = (props) => {
  const withDefaults = { ...defaults3, ...props };
  const options = toWritableStores(omit(withDefaults, "loadingStatus", "onLoadingStatusChange"));
  const { src, delayMs } = options;
  const loadingStatusWritable = withDefaults.loadingStatus ?? writable("loading");
  const loadingStatus = overridable(loadingStatusWritable, withDefaults == null ? void 0 : withDefaults.onLoadingStatusChange);
  effect([src, delayMs], ([$src, $delayMs]) => {
    if (isBrowser) {
      const image2 = new Image();
      image2.src = $src;
      image2.onload = () => {
        if (delayMs !== void 0) {
          const timerId = window.setTimeout(() => {
            loadingStatus.set("loaded");
          }, $delayMs);
          return () => window.clearTimeout(timerId);
        } else {
          loadingStatus.set("loaded");
        }
      };
      image2.onerror = () => {
        loadingStatus.set("error");
      };
    }
  });
  const image = makeElement("avatar-image", {
    stores: [src, loadingStatus],
    returned: ([$src, $loadingStatus]) => {
      const imageStyles = styleToString({
        display: $loadingStatus === "loaded" ? "block" : "none"
      });
      return {
        src: $src,
        style: imageStyles
      };
    }
  });
  const fallback = makeElement("avatar-fallback", {
    stores: [loadingStatus],
    returned: ([$loadingStatus]) => {
      return {
        style: $loadingStatus === "loaded" ? styleToString({
          display: "none"
        }) : void 0,
        hidden: $loadingStatus === "loaded" ? true : void 0
      };
    }
  });
  return {
    elements: {
      image,
      fallback
    },
    states: {
      loadingStatus
    },
    options
  };
};

// node_modules/@melt-ui/svelte/dist/builders/checkbox/create.js
var defaults4 = {
  disabled: false,
  required: false,
  name: void 0,
  value: "on",
  defaultChecked: false
};
function createCheckbox(props) {
  const withDefaults = { ...defaults4, ...props };
  const options = toWritableStores(omit(withDefaults, "checked", "defaultChecked"));
  const { disabled, name: name27, required, value } = options;
  const checkedWritable = withDefaults.checked ?? writable(withDefaults.defaultChecked);
  const checked = overridable(checkedWritable, withDefaults == null ? void 0 : withDefaults.onCheckedChange);
  const root = makeElement("checkbox", {
    stores: [checked, disabled, required],
    returned: ([$checked, $disabled, $required]) => {
      return {
        "data-disabled": disabledAttr($disabled),
        disabled: disabledAttr($disabled),
        "data-state": $checked === "indeterminate" ? "indeterminate" : $checked ? "checked" : "unchecked",
        type: "button",
        role: "checkbox",
        "aria-checked": $checked === "indeterminate" ? "mixed" : $checked,
        "aria-required": $required
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "keydown", (e) => {
        if (e.key === kbd.ENTER)
          e.preventDefault();
      }), addMeltEventListener(node, "click", () => {
        if (disabled.get())
          return;
        checked.update((value2) => {
          if (value2 === "indeterminate")
            return true;
          return !value2;
        });
      }));
      return {
        destroy: unsub
      };
    }
  });
  const input = makeElement("checkbox-input", {
    stores: [checked, name27, value, required, disabled],
    returned: ([$checked, $name, $value, $required, $disabled]) => {
      return {
        type: "checkbox",
        "aria-hidden": true,
        hidden: true,
        tabindex: -1,
        name: $name,
        value: $value,
        checked: $checked === "indeterminate" ? false : $checked,
        required: $required,
        disabled: disabledAttr($disabled),
        style: styleToString({
          position: "absolute",
          opacity: 0,
          "pointer-events": "none",
          margin: 0,
          transform: "translateX(-100%)"
        })
      };
    }
  });
  const isIndeterminate = derived(checked, ($checked) => $checked === "indeterminate");
  const isChecked = derived(checked, ($checked) => $checked === true);
  return {
    elements: {
      root,
      input
    },
    states: {
      checked
    },
    helpers: {
      isIndeterminate,
      isChecked
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/collapsible/create.js
var defaults5 = {
  defaultOpen: false,
  disabled: false,
  forceVisible: false
};
var { name: name2 } = createElHelpers("collapsible");
function createCollapsible(props) {
  const withDefaults = { ...defaults5, ...props };
  const options = toWritableStores(omit(withDefaults, "open", "defaultOpen", "onOpenChange"));
  const { disabled, forceVisible } = options;
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const open = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const root = makeElement(name2(), {
    stores: [open, disabled],
    returned: ([$open, $disabled]) => ({
      "data-state": $open ? "open" : "closed",
      "data-disabled": disabledAttr($disabled)
    })
  });
  const trigger = makeElement(name2("trigger"), {
    stores: [open, disabled],
    returned: ([$open, $disabled]) => ({
      "data-state": $open ? "open" : "closed",
      "data-disabled": disabledAttr($disabled),
      disabled: disabledAttr($disabled)
    }),
    action: (node) => {
      const unsub = addMeltEventListener(node, "click", () => {
        const disabled2 = node.dataset.disabled !== void 0;
        if (disabled2)
          return;
        open.update(($open) => !$open);
      });
      return {
        destroy: unsub
      };
    }
  });
  const isVisible = derived([open, forceVisible], ([$open, $forceVisible]) => $open || $forceVisible);
  const content = makeElement(name2("content"), {
    stores: [isVisible, disabled],
    returned: ([$isVisible, $disabled]) => ({
      "data-state": $isVisible ? "open" : "closed",
      "data-disabled": disabledAttr($disabled),
      hidden: $isVisible ? void 0 : true,
      style: styleToString({
        display: $isVisible ? void 0 : "none"
      })
    })
  });
  return {
    elements: {
      root,
      trigger,
      content
    },
    states: {
      open
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/internal/actions/click-outside/action.js
var documentClickStore = readable(void 0, (set) => {
  function clicked(event) {
    set(event);
    set(void 0);
  }
  const unsubscribe = addEventListener(document, "pointerup", clicked, {
    passive: false,
    capture: true
  });
  return unsubscribe;
});

// node_modules/@melt-ui/svelte/dist/internal/actions/escape-keydown/action.js
var documentEscapeKeyStore = readable(void 0, (set) => {
  function keydown(event) {
    if (event && event.key === kbd.ESCAPE) {
      set(event);
    }
    set(void 0);
  }
  const unsubscribe = addEventListener(document, "keydown", keydown, {
    passive: false
  });
  return unsubscribe;
});
var useEscapeKeydown = (node, config = {}) => {
  let unsub = noop2;
  function update(config2 = {}) {
    unsub();
    const options = { enabled: true, ...config2 };
    const enabled = isReadable(options.enabled) ? options.enabled : readable(options.enabled);
    unsub = executeCallbacks(
      // Handle escape keydowns
      documentEscapeKeyStore.subscribe((e) => {
        var _a;
        if (!e || !get_store_value(enabled))
          return;
        const target = e.target;
        if (!isHTMLElement(target) || target.closest("[data-escapee]") !== node) {
          return;
        }
        e.preventDefault();
        if (options.ignore) {
          if (isFunction(options.ignore)) {
            if (options.ignore(e))
              return;
          } else if (Array.isArray(options.ignore)) {
            if (options.ignore.length > 0 && options.ignore.some((ignoreEl) => {
              return ignoreEl && target === ignoreEl;
            }))
              return;
          }
        }
        (_a = options.handler) == null ? void 0 : _a.call(options, e);
      }),
      effect(enabled, ($enabled) => {
        if ($enabled) {
          node.dataset.escapee = "";
        } else {
          delete node.dataset.escapee;
        }
      })
    );
  }
  update(config);
  return {
    update,
    destroy() {
      node.removeAttribute("data-escapee");
      unsub();
    }
  };
};

// node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs
var sides = ["top", "right", "bottom", "left"];
var alignments = ["start", "end"];
var placements = sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []);
var min = Math.min;
var max = Math.max;
var round = Math.round;
var floor = Math.floor;
var createCoords = (v) => ({
  x: v,
  y: v
});
var oppositeSideMap = {
  left: "right",
  right: "left",
  bottom: "top",
  top: "bottom"
};
var oppositeAlignmentMap = {
  start: "end",
  end: "start"
};
function clamp2(start, value, end) {
  return max(start, min(value, end));
}
function evaluate(value, param) {
  return typeof value === "function" ? value(param) : value;
}
function getSide(placement) {
  return placement.split("-")[0];
}
function getAlignment(placement) {
  return placement.split("-")[1];
}
function getOppositeAxis(axis) {
  return axis === "x" ? "y" : "x";
}
function getAxisLength(axis) {
  return axis === "y" ? "height" : "width";
}
function getSideAxis(placement) {
  return ["top", "bottom"].includes(getSide(placement)) ? "y" : "x";
}
function getAlignmentAxis(placement) {
  return getOppositeAxis(getSideAxis(placement));
}
function getAlignmentSides(placement, rects, rtl) {
  if (rtl === void 0) {
    rtl = false;
  }
  const alignment = getAlignment(placement);
  const alignmentAxis = getAlignmentAxis(placement);
  const length = getAxisLength(alignmentAxis);
  let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top";
  if (rects.reference[length] > rects.floating[length]) {
    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);
  }
  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];
}
function getExpandedPlacements(placement) {
  const oppositePlacement = getOppositePlacement(placement);
  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];
}
function getOppositeAlignmentPlacement(placement) {
  return placement.replace(/start|end/g, (alignment) => oppositeAlignmentMap[alignment]);
}
function getSideList(side, isStart, rtl) {
  const lr = ["left", "right"];
  const rl = ["right", "left"];
  const tb = ["top", "bottom"];
  const bt = ["bottom", "top"];
  switch (side) {
    case "top":
    case "bottom":
      if (rtl) return isStart ? rl : lr;
      return isStart ? lr : rl;
    case "left":
    case "right":
      return isStart ? tb : bt;
    default:
      return [];
  }
}
function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {
  const alignment = getAlignment(placement);
  let list = getSideList(getSide(placement), direction === "start", rtl);
  if (alignment) {
    list = list.map((side) => side + "-" + alignment);
    if (flipAlignment) {
      list = list.concat(list.map(getOppositeAlignmentPlacement));
    }
  }
  return list;
}
function getOppositePlacement(placement) {
  return placement.replace(/left|right|bottom|top/g, (side) => oppositeSideMap[side]);
}
function expandPaddingObject(padding) {
  return {
    top: 0,
    right: 0,
    bottom: 0,
    left: 0,
    ...padding
  };
}
function getPaddingObject(padding) {
  return typeof padding !== "number" ? expandPaddingObject(padding) : {
    top: padding,
    right: padding,
    bottom: padding,
    left: padding
  };
}
function rectToClientRect(rect) {
  return {
    ...rect,
    top: rect.y,
    left: rect.x,
    right: rect.x + rect.width,
    bottom: rect.y + rect.height
  };
}

// node_modules/@floating-ui/core/dist/floating-ui.core.mjs
function computeCoordsFromPlacement(_ref, placement, rtl) {
  let {
    reference,
    floating
  } = _ref;
  const sideAxis = getSideAxis(placement);
  const alignmentAxis = getAlignmentAxis(placement);
  const alignLength = getAxisLength(alignmentAxis);
  const side = getSide(placement);
  const isVertical = sideAxis === "y";
  const commonX = reference.x + reference.width / 2 - floating.width / 2;
  const commonY = reference.y + reference.height / 2 - floating.height / 2;
  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
  let coords;
  switch (side) {
    case "top":
      coords = {
        x: commonX,
        y: reference.y - floating.height
      };
      break;
    case "bottom":
      coords = {
        x: commonX,
        y: reference.y + reference.height
      };
      break;
    case "right":
      coords = {
        x: reference.x + reference.width,
        y: commonY
      };
      break;
    case "left":
      coords = {
        x: reference.x - floating.width,
        y: commonY
      };
      break;
    default:
      coords = {
        x: reference.x,
        y: reference.y
      };
  }
  switch (getAlignment(placement)) {
    case "start":
      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
      break;
    case "end":
      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
      break;
  }
  return coords;
}
var computePosition = async (reference, floating, config) => {
  const {
    placement = "bottom",
    strategy = "absolute",
    middleware = [],
    platform: platform2
  } = config;
  const validMiddleware = middleware.filter(Boolean);
  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating));
  let rects = await platform2.getElementRects({
    reference,
    floating,
    strategy
  });
  let {
    x,
    y
  } = computeCoordsFromPlacement(rects, placement, rtl);
  let statefulPlacement = placement;
  let middlewareData = {};
  let resetCount = 0;
  for (let i = 0; i < validMiddleware.length; i++) {
    const {
      name: name27,
      fn
    } = validMiddleware[i];
    const {
      x: nextX,
      y: nextY,
      data,
      reset
    } = await fn({
      x,
      y,
      initialPlacement: placement,
      placement: statefulPlacement,
      strategy,
      middlewareData,
      rects,
      platform: platform2,
      elements: {
        reference,
        floating
      }
    });
    x = nextX != null ? nextX : x;
    y = nextY != null ? nextY : y;
    middlewareData = {
      ...middlewareData,
      [name27]: {
        ...middlewareData[name27],
        ...data
      }
    };
    if (reset && resetCount <= 50) {
      resetCount++;
      if (typeof reset === "object") {
        if (reset.placement) {
          statefulPlacement = reset.placement;
        }
        if (reset.rects) {
          rects = reset.rects === true ? await platform2.getElementRects({
            reference,
            floating,
            strategy
          }) : reset.rects;
        }
        ({
          x,
          y
        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
      }
      i = -1;
    }
  }
  return {
    x,
    y,
    placement: statefulPlacement,
    strategy,
    middlewareData
  };
};
async function detectOverflow(state, options) {
  var _await$platform$isEle;
  if (options === void 0) {
    options = {};
  }
  const {
    x,
    y,
    platform: platform2,
    rects,
    elements,
    strategy
  } = state;
  const {
    boundary = "clippingAncestors",
    rootBoundary = "viewport",
    elementContext = "floating",
    altBoundary = false,
    padding = 0
  } = evaluate(options, state);
  const paddingObject = getPaddingObject(padding);
  const altContext = elementContext === "floating" ? "reference" : "floating";
  const element2 = elements[altBoundary ? altContext : elementContext];
  const clippingClientRect = rectToClientRect(await platform2.getClippingRect({
    element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element2))) != null ? _await$platform$isEle : true) ? element2 : element2.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)),
    boundary,
    rootBoundary,
    strategy
  }));
  const rect = elementContext === "floating" ? {
    ...rects.floating,
    x,
    y
  } : rects.reference;
  const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating));
  const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || {
    x: 1,
    y: 1
  } : {
    x: 1,
    y: 1
  };
  const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({
    elements,
    rect,
    offsetParent,
    strategy
  }) : rect);
  return {
    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
  };
}
var arrow = (options) => ({
  name: "arrow",
  options,
  async fn(state) {
    const {
      x,
      y,
      placement,
      rects,
      platform: platform2,
      elements,
      middlewareData
    } = state;
    const {
      element: element2,
      padding = 0
    } = evaluate(options, state) || {};
    if (element2 == null) {
      return {};
    }
    const paddingObject = getPaddingObject(padding);
    const coords = {
      x,
      y
    };
    const axis = getAlignmentAxis(placement);
    const length = getAxisLength(axis);
    const arrowDimensions = await platform2.getDimensions(element2);
    const isYAxis = axis === "y";
    const minProp = isYAxis ? "top" : "left";
    const maxProp = isYAxis ? "bottom" : "right";
    const clientProp = isYAxis ? "clientHeight" : "clientWidth";
    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
    const startDiff = coords[axis] - rects.reference[axis];
    const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element2));
    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;
    if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) {
      clientSize = elements.floating[clientProp] || rects.floating[length];
    }
    const centerToReference = endDiff / 2 - startDiff / 2;
    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;
    const minPadding = min(paddingObject[minProp], largestPossiblePadding);
    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);
    const min$1 = minPadding;
    const max2 = clientSize - arrowDimensions[length] - maxPadding;
    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
    const offset2 = clamp2(min$1, center, max2);
    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset2 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;
    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0;
    return {
      [axis]: coords[axis] + alignmentOffset,
      data: {
        [axis]: offset2,
        centerOffset: center - offset2 - alignmentOffset,
        ...shouldAddOffset && {
          alignmentOffset
        }
      },
      reset: shouldAddOffset
    };
  }
});
var flip = function(options) {
  if (options === void 0) {
    options = {};
  }
  return {
    name: "flip",
    options,
    async fn(state) {
      var _middlewareData$arrow, _middlewareData$flip;
      const {
        placement,
        middlewareData,
        rects,
        initialPlacement,
        platform: platform2,
        elements
      } = state;
      const {
        mainAxis: checkMainAxis = true,
        crossAxis: checkCrossAxis = true,
        fallbackPlacements: specifiedFallbackPlacements,
        fallbackStrategy = "bestFit",
        fallbackAxisSideDirection = "none",
        flipAlignment = true,
        ...detectOverflowOptions
      } = evaluate(options, state);
      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
        return {};
      }
      const side = getSide(placement);
      const isBasePlacement = getSide(initialPlacement) === initialPlacement;
      const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));
      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== "none") {
        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));
      }
      const placements2 = [initialPlacement, ...fallbackPlacements];
      const overflow = await detectOverflow(state, detectOverflowOptions);
      const overflows = [];
      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];
      if (checkMainAxis) {
        overflows.push(overflow[side]);
      }
      if (checkCrossAxis) {
        const sides2 = getAlignmentSides(placement, rects, rtl);
        overflows.push(overflow[sides2[0]], overflow[sides2[1]]);
      }
      overflowsData = [...overflowsData, {
        placement,
        overflows
      }];
      if (!overflows.every((side2) => side2 <= 0)) {
        var _middlewareData$flip2, _overflowsData$filter;
        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;
        const nextPlacement = placements2[nextIndex];
        if (nextPlacement) {
          return {
            data: {
              index: nextIndex,
              overflows: overflowsData
            },
            reset: {
              placement: nextPlacement
            }
          };
        }
        let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;
        if (!resetPlacement) {
          switch (fallbackStrategy) {
            case "bestFit": {
              var _overflowsData$map$so;
              const placement2 = (_overflowsData$map$so = overflowsData.map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$map$so[0];
              if (placement2) {
                resetPlacement = placement2;
              }
              break;
            }
            case "initialPlacement":
              resetPlacement = initialPlacement;
              break;
          }
        }
        if (placement !== resetPlacement) {
          return {
            reset: {
              placement: resetPlacement
            }
          };
        }
      }
      return {};
    }
  };
};
async function convertValueToCoords(state, options) {
  const {
    placement,
    platform: platform2,
    elements
  } = state;
  const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating));
  const side = getSide(placement);
  const alignment = getAlignment(placement);
  const isVertical = getSideAxis(placement) === "y";
  const mainAxisMulti = ["left", "top"].includes(side) ? -1 : 1;
  const crossAxisMulti = rtl && isVertical ? -1 : 1;
  const rawValue = evaluate(options, state);
  let {
    mainAxis,
    crossAxis,
    alignmentAxis
  } = typeof rawValue === "number" ? {
    mainAxis: rawValue,
    crossAxis: 0,
    alignmentAxis: null
  } : {
    mainAxis: 0,
    crossAxis: 0,
    alignmentAxis: null,
    ...rawValue
  };
  if (alignment && typeof alignmentAxis === "number") {
    crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis;
  }
  return isVertical ? {
    x: crossAxis * crossAxisMulti,
    y: mainAxis * mainAxisMulti
  } : {
    x: mainAxis * mainAxisMulti,
    y: crossAxis * crossAxisMulti
  };
}
var offset = function(options) {
  if (options === void 0) {
    options = 0;
  }
  return {
    name: "offset",
    options,
    async fn(state) {
      var _middlewareData$offse, _middlewareData$arrow;
      const {
        x,
        y,
        placement,
        middlewareData
      } = state;
      const diffCoords = await convertValueToCoords(state, options);
      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
        return {};
      }
      return {
        x: x + diffCoords.x,
        y: y + diffCoords.y,
        data: {
          ...diffCoords,
          placement
        }
      };
    }
  };
};
var shift = function(options) {
  if (options === void 0) {
    options = {};
  }
  return {
    name: "shift",
    options,
    async fn(state) {
      const {
        x,
        y,
        placement
      } = state;
      const {
        mainAxis: checkMainAxis = true,
        crossAxis: checkCrossAxis = false,
        limiter = {
          fn: (_ref) => {
            let {
              x: x2,
              y: y2
            } = _ref;
            return {
              x: x2,
              y: y2
            };
          }
        },
        ...detectOverflowOptions
      } = evaluate(options, state);
      const coords = {
        x,
        y
      };
      const overflow = await detectOverflow(state, detectOverflowOptions);
      const crossAxis = getSideAxis(getSide(placement));
      const mainAxis = getOppositeAxis(crossAxis);
      let mainAxisCoord = coords[mainAxis];
      let crossAxisCoord = coords[crossAxis];
      if (checkMainAxis) {
        const minSide = mainAxis === "y" ? "top" : "left";
        const maxSide = mainAxis === "y" ? "bottom" : "right";
        const min2 = mainAxisCoord + overflow[minSide];
        const max2 = mainAxisCoord - overflow[maxSide];
        mainAxisCoord = clamp2(min2, mainAxisCoord, max2);
      }
      if (checkCrossAxis) {
        const minSide = crossAxis === "y" ? "top" : "left";
        const maxSide = crossAxis === "y" ? "bottom" : "right";
        const min2 = crossAxisCoord + overflow[minSide];
        const max2 = crossAxisCoord - overflow[maxSide];
        crossAxisCoord = clamp2(min2, crossAxisCoord, max2);
      }
      const limitedCoords = limiter.fn({
        ...state,
        [mainAxis]: mainAxisCoord,
        [crossAxis]: crossAxisCoord
      });
      return {
        ...limitedCoords,
        data: {
          x: limitedCoords.x - x,
          y: limitedCoords.y - y
        }
      };
    }
  };
};
var size = function(options) {
  if (options === void 0) {
    options = {};
  }
  return {
    name: "size",
    options,
    async fn(state) {
      const {
        placement,
        rects,
        platform: platform2,
        elements
      } = state;
      const {
        apply = () => {
        },
        ...detectOverflowOptions
      } = evaluate(options, state);
      const overflow = await detectOverflow(state, detectOverflowOptions);
      const side = getSide(placement);
      const alignment = getAlignment(placement);
      const isYAxis = getSideAxis(placement) === "y";
      const {
        width,
        height
      } = rects.floating;
      let heightSide;
      let widthSide;
      if (side === "top" || side === "bottom") {
        heightSide = side;
        widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right";
      } else {
        widthSide = side;
        heightSide = alignment === "end" ? "top" : "bottom";
      }
      const overflowAvailableHeight = height - overflow[heightSide];
      const overflowAvailableWidth = width - overflow[widthSide];
      const noShift = !state.middlewareData.shift;
      let availableHeight = overflowAvailableHeight;
      let availableWidth = overflowAvailableWidth;
      if (isYAxis) {
        const maximumClippingWidth = width - overflow.left - overflow.right;
        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;
      } else {
        const maximumClippingHeight = height - overflow.top - overflow.bottom;
        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : maximumClippingHeight;
      }
      if (noShift && !alignment) {
        const xMin = max(overflow.left, 0);
        const xMax = max(overflow.right, 0);
        const yMin = max(overflow.top, 0);
        const yMax = max(overflow.bottom, 0);
        if (isYAxis) {
          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));
        } else {
          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));
        }
      }
      await apply({
        ...state,
        availableWidth,
        availableHeight
      });
      const nextDimensions = await platform2.getDimensions(elements.floating);
      if (width !== nextDimensions.width || height !== nextDimensions.height) {
        return {
          reset: {
            rects: true
          }
        };
      }
      return {};
    }
  };
};

// node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
function getNodeName(node) {
  if (isNode(node)) {
    return (node.nodeName || "").toLowerCase();
  }
  return "#document";
}
function getWindow(node) {
  var _node$ownerDocument;
  return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
}
function getDocumentElement(node) {
  var _ref;
  return (_ref = (isNode(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement;
}
function isNode(value) {
  return value instanceof Node || value instanceof getWindow(value).Node;
}
function isElement2(value) {
  return value instanceof Element || value instanceof getWindow(value).Element;
}
function isHTMLElement2(value) {
  return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
}
function isShadowRoot(value) {
  if (typeof ShadowRoot === "undefined") {
    return false;
  }
  return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot;
}
function isOverflowElement(element2) {
  const {
    overflow,
    overflowX,
    overflowY,
    display
  } = getComputedStyle2(element2);
  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !["inline", "contents"].includes(display);
}
function isTableElement(element2) {
  return ["table", "td", "th"].includes(getNodeName(element2));
}
function isContainingBlock(element2) {
  const webkit = isWebKit();
  const css = getComputedStyle2(element2);
  return css.transform !== "none" || css.perspective !== "none" || (css.containerType ? css.containerType !== "normal" : false) || !webkit && (css.backdropFilter ? css.backdropFilter !== "none" : false) || !webkit && (css.filter ? css.filter !== "none" : false) || ["transform", "perspective", "filter"].some((value) => (css.willChange || "").includes(value)) || ["paint", "layout", "strict", "content"].some((value) => (css.contain || "").includes(value));
}
function getContainingBlock(element2) {
  let currentNode = getParentNode(element2);
  while (isHTMLElement2(currentNode) && !isLastTraversableNode(currentNode)) {
    if (isContainingBlock(currentNode)) {
      return currentNode;
    } else {
      currentNode = getParentNode(currentNode);
    }
  }
  return null;
}
function isWebKit() {
  if (typeof CSS === "undefined" || !CSS.supports) return false;
  return CSS.supports("-webkit-backdrop-filter", "none");
}
function isLastTraversableNode(node) {
  return ["html", "body", "#document"].includes(getNodeName(node));
}
function getComputedStyle2(element2) {
  return getWindow(element2).getComputedStyle(element2);
}
function getNodeScroll(element2) {
  if (isElement2(element2)) {
    return {
      scrollLeft: element2.scrollLeft,
      scrollTop: element2.scrollTop
    };
  }
  return {
    scrollLeft: element2.pageXOffset,
    scrollTop: element2.pageYOffset
  };
}
function getParentNode(node) {
  if (getNodeName(node) === "html") {
    return node;
  }
  const result = (
    // Step into the shadow DOM of the parent of a slotted node.
    node.assignedSlot || // DOM Element detected.
    node.parentNode || // ShadowRoot detected.
    isShadowRoot(node) && node.host || // Fallback.
    getDocumentElement(node)
  );
  return isShadowRoot(result) ? result.host : result;
}
function getNearestOverflowAncestor(node) {
  const parentNode = getParentNode(node);
  if (isLastTraversableNode(parentNode)) {
    return node.ownerDocument ? node.ownerDocument.body : node.body;
  }
  if (isHTMLElement2(parentNode) && isOverflowElement(parentNode)) {
    return parentNode;
  }
  return getNearestOverflowAncestor(parentNode);
}
function getOverflowAncestors(node, list, traverseIframes) {
  var _node$ownerDocument2;
  if (list === void 0) {
    list = [];
  }
  if (traverseIframes === void 0) {
    traverseIframes = true;
  }
  const scrollableAncestor = getNearestOverflowAncestor(node);
  const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body);
  const win = getWindow(scrollableAncestor);
  if (isBody) {
    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], win.frameElement && traverseIframes ? getOverflowAncestors(win.frameElement) : []);
  }
  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes));
}

// node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs
function getCssDimensions(element2) {
  const css = getComputedStyle2(element2);
  let width = parseFloat(css.width) || 0;
  let height = parseFloat(css.height) || 0;
  const hasOffset = isHTMLElement2(element2);
  const offsetWidth = hasOffset ? element2.offsetWidth : width;
  const offsetHeight = hasOffset ? element2.offsetHeight : height;
  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;
  if (shouldFallback) {
    width = offsetWidth;
    height = offsetHeight;
  }
  return {
    width,
    height,
    $: shouldFallback
  };
}
function unwrapElement(element2) {
  return !isElement2(element2) ? element2.contextElement : element2;
}
function getScale(element2) {
  const domElement = unwrapElement(element2);
  if (!isHTMLElement2(domElement)) {
    return createCoords(1);
  }
  const rect = domElement.getBoundingClientRect();
  const {
    width,
    height,
    $
  } = getCssDimensions(domElement);
  let x = ($ ? round(rect.width) : rect.width) / width;
  let y = ($ ? round(rect.height) : rect.height) / height;
  if (!x || !Number.isFinite(x)) {
    x = 1;
  }
  if (!y || !Number.isFinite(y)) {
    y = 1;
  }
  return {
    x,
    y
  };
}
var noOffsets = createCoords(0);
function getVisualOffsets(element2) {
  const win = getWindow(element2);
  if (!isWebKit() || !win.visualViewport) {
    return noOffsets;
  }
  return {
    x: win.visualViewport.offsetLeft,
    y: win.visualViewport.offsetTop
  };
}
function shouldAddVisualOffsets(element2, isFixed, floatingOffsetParent) {
  if (isFixed === void 0) {
    isFixed = false;
  }
  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element2)) {
    return false;
  }
  return isFixed;
}
function getBoundingClientRect(element2, includeScale, isFixedStrategy, offsetParent) {
  if (includeScale === void 0) {
    includeScale = false;
  }
  if (isFixedStrategy === void 0) {
    isFixedStrategy = false;
  }
  const clientRect = element2.getBoundingClientRect();
  const domElement = unwrapElement(element2);
  let scale = createCoords(1);
  if (includeScale) {
    if (offsetParent) {
      if (isElement2(offsetParent)) {
        scale = getScale(offsetParent);
      }
    } else {
      scale = getScale(element2);
    }
  }
  const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0);
  let x = (clientRect.left + visualOffsets.x) / scale.x;
  let y = (clientRect.top + visualOffsets.y) / scale.y;
  let width = clientRect.width / scale.x;
  let height = clientRect.height / scale.y;
  if (domElement) {
    const win = getWindow(domElement);
    const offsetWin = offsetParent && isElement2(offsetParent) ? getWindow(offsetParent) : offsetParent;
    let currentWin = win;
    let currentIFrame = currentWin.frameElement;
    while (currentIFrame && offsetParent && offsetWin !== currentWin) {
      const iframeScale = getScale(currentIFrame);
      const iframeRect = currentIFrame.getBoundingClientRect();
      const css = getComputedStyle2(currentIFrame);
      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;
      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;
      x *= iframeScale.x;
      y *= iframeScale.y;
      width *= iframeScale.x;
      height *= iframeScale.y;
      x += left;
      y += top;
      currentWin = getWindow(currentIFrame);
      currentIFrame = currentWin.frameElement;
    }
  }
  return rectToClientRect({
    width,
    height,
    x,
    y
  });
}
var topLayerSelectors = [":popover-open", ":modal"];
function isTopLayer(floating) {
  return topLayerSelectors.some((selector10) => {
    try {
      return floating.matches(selector10);
    } catch (e) {
      return false;
    }
  });
}
function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
  let {
    elements,
    rect,
    offsetParent,
    strategy
  } = _ref;
  const isFixed = strategy === "fixed";
  const documentElement = getDocumentElement(offsetParent);
  const topLayer = elements ? isTopLayer(elements.floating) : false;
  if (offsetParent === documentElement || topLayer && isFixed) {
    return rect;
  }
  let scroll = {
    scrollLeft: 0,
    scrollTop: 0
  };
  let scale = createCoords(1);
  const offsets = createCoords(0);
  const isOffsetParentAnElement = isHTMLElement2(offsetParent);
  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
      scroll = getNodeScroll(offsetParent);
    }
    if (isHTMLElement2(offsetParent)) {
      const offsetRect = getBoundingClientRect(offsetParent);
      scale = getScale(offsetParent);
      offsets.x = offsetRect.x + offsetParent.clientLeft;
      offsets.y = offsetRect.y + offsetParent.clientTop;
    }
  }
  return {
    width: rect.width * scale.x,
    height: rect.height * scale.y,
    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,
    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y
  };
}
function getClientRects(element2) {
  return Array.from(element2.getClientRects());
}
function getWindowScrollBarX(element2) {
  return getBoundingClientRect(getDocumentElement(element2)).left + getNodeScroll(element2).scrollLeft;
}
function getDocumentRect(element2) {
  const html = getDocumentElement(element2);
  const scroll = getNodeScroll(element2);
  const body = element2.ownerDocument.body;
  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);
  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);
  let x = -scroll.scrollLeft + getWindowScrollBarX(element2);
  const y = -scroll.scrollTop;
  if (getComputedStyle2(body).direction === "rtl") {
    x += max(html.clientWidth, body.clientWidth) - width;
  }
  return {
    width,
    height,
    x,
    y
  };
}
function getViewportRect(element2, strategy) {
  const win = getWindow(element2);
  const html = getDocumentElement(element2);
  const visualViewport = win.visualViewport;
  let width = html.clientWidth;
  let height = html.clientHeight;
  let x = 0;
  let y = 0;
  if (visualViewport) {
    width = visualViewport.width;
    height = visualViewport.height;
    const visualViewportBased = isWebKit();
    if (!visualViewportBased || visualViewportBased && strategy === "fixed") {
      x = visualViewport.offsetLeft;
      y = visualViewport.offsetTop;
    }
  }
  return {
    width,
    height,
    x,
    y
  };
}
function getInnerBoundingClientRect(element2, strategy) {
  const clientRect = getBoundingClientRect(element2, true, strategy === "fixed");
  const top = clientRect.top + element2.clientTop;
  const left = clientRect.left + element2.clientLeft;
  const scale = isHTMLElement2(element2) ? getScale(element2) : createCoords(1);
  const width = element2.clientWidth * scale.x;
  const height = element2.clientHeight * scale.y;
  const x = left * scale.x;
  const y = top * scale.y;
  return {
    width,
    height,
    x,
    y
  };
}
function getClientRectFromClippingAncestor(element2, clippingAncestor, strategy) {
  let rect;
  if (clippingAncestor === "viewport") {
    rect = getViewportRect(element2, strategy);
  } else if (clippingAncestor === "document") {
    rect = getDocumentRect(getDocumentElement(element2));
  } else if (isElement2(clippingAncestor)) {
    rect = getInnerBoundingClientRect(clippingAncestor, strategy);
  } else {
    const visualOffsets = getVisualOffsets(element2);
    rect = {
      ...clippingAncestor,
      x: clippingAncestor.x - visualOffsets.x,
      y: clippingAncestor.y - visualOffsets.y
    };
  }
  return rectToClientRect(rect);
}
function hasFixedPositionAncestor(element2, stopNode) {
  const parentNode = getParentNode(element2);
  if (parentNode === stopNode || !isElement2(parentNode) || isLastTraversableNode(parentNode)) {
    return false;
  }
  return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode);
}
function getClippingElementAncestors(element2, cache) {
  const cachedResult = cache.get(element2);
  if (cachedResult) {
    return cachedResult;
  }
  let result = getOverflowAncestors(element2, [], false).filter((el) => isElement2(el) && getNodeName(el) !== "body");
  let currentContainingBlockComputedStyle = null;
  const elementIsFixed = getComputedStyle2(element2).position === "fixed";
  let currentNode = elementIsFixed ? getParentNode(element2) : element2;
  while (isElement2(currentNode) && !isLastTraversableNode(currentNode)) {
    const computedStyle = getComputedStyle2(currentNode);
    const currentNodeIsContaining = isContainingBlock(currentNode);
    if (!currentNodeIsContaining && computedStyle.position === "fixed") {
      currentContainingBlockComputedStyle = null;
    }
    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && ["absolute", "fixed"].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element2, currentNode);
    if (shouldDropCurrentNode) {
      result = result.filter((ancestor) => ancestor !== currentNode);
    } else {
      currentContainingBlockComputedStyle = computedStyle;
    }
    currentNode = getParentNode(currentNode);
  }
  cache.set(element2, result);
  return result;
}
function getClippingRect(_ref) {
  let {
    element: element2,
    boundary,
    rootBoundary,
    strategy
  } = _ref;
  const elementClippingAncestors = boundary === "clippingAncestors" ? getClippingElementAncestors(element2, this._c) : [].concat(boundary);
  const clippingAncestors = [...elementClippingAncestors, rootBoundary];
  const firstClippingAncestor = clippingAncestors[0];
  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
    const rect = getClientRectFromClippingAncestor(element2, clippingAncestor, strategy);
    accRect.top = max(rect.top, accRect.top);
    accRect.right = min(rect.right, accRect.right);
    accRect.bottom = min(rect.bottom, accRect.bottom);
    accRect.left = max(rect.left, accRect.left);
    return accRect;
  }, getClientRectFromClippingAncestor(element2, firstClippingAncestor, strategy));
  return {
    width: clippingRect.right - clippingRect.left,
    height: clippingRect.bottom - clippingRect.top,
    x: clippingRect.left,
    y: clippingRect.top
  };
}
function getDimensions(element2) {
  const {
    width,
    height
  } = getCssDimensions(element2);
  return {
    width,
    height
  };
}
function getRectRelativeToOffsetParent(element2, offsetParent, strategy) {
  const isOffsetParentAnElement = isHTMLElement2(offsetParent);
  const documentElement = getDocumentElement(offsetParent);
  const isFixed = strategy === "fixed";
  const rect = getBoundingClientRect(element2, true, isFixed, offsetParent);
  let scroll = {
    scrollLeft: 0,
    scrollTop: 0
  };
  const offsets = createCoords(0);
  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {
    if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) {
      scroll = getNodeScroll(offsetParent);
    }
    if (isOffsetParentAnElement) {
      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);
      offsets.x = offsetRect.x + offsetParent.clientLeft;
      offsets.y = offsetRect.y + offsetParent.clientTop;
    } else if (documentElement) {
      offsets.x = getWindowScrollBarX(documentElement);
    }
  }
  const x = rect.left + scroll.scrollLeft - offsets.x;
  const y = rect.top + scroll.scrollTop - offsets.y;
  return {
    x,
    y,
    width: rect.width,
    height: rect.height
  };
}
function getTrueOffsetParent(element2, polyfill) {
  if (!isHTMLElement2(element2) || getComputedStyle2(element2).position === "fixed") {
    return null;
  }
  if (polyfill) {
    return polyfill(element2);
  }
  return element2.offsetParent;
}
function getOffsetParent(element2, polyfill) {
  const window2 = getWindow(element2);
  if (!isHTMLElement2(element2) || isTopLayer(element2)) {
    return window2;
  }
  let offsetParent = getTrueOffsetParent(element2, polyfill);
  while (offsetParent && isTableElement(offsetParent) && getComputedStyle2(offsetParent).position === "static") {
    offsetParent = getTrueOffsetParent(offsetParent, polyfill);
  }
  if (offsetParent && (getNodeName(offsetParent) === "html" || getNodeName(offsetParent) === "body" && getComputedStyle2(offsetParent).position === "static" && !isContainingBlock(offsetParent))) {
    return window2;
  }
  return offsetParent || getContainingBlock(element2) || window2;
}
var getElementRects = async function(data) {
  const getOffsetParentFn = this.getOffsetParent || getOffsetParent;
  const getDimensionsFn = this.getDimensions;
  return {
    reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy),
    floating: {
      x: 0,
      y: 0,
      ...await getDimensionsFn(data.floating)
    }
  };
};
function isRTL(element2) {
  return getComputedStyle2(element2).direction === "rtl";
}
var platform = {
  convertOffsetParentRelativeRectToViewportRelativeRect,
  getDocumentElement,
  getClippingRect,
  getOffsetParent,
  getElementRects,
  getClientRects,
  getDimensions,
  getScale,
  isElement: isElement2,
  isRTL
};
function observeMove(element2, onMove) {
  let io = null;
  let timeoutId;
  const root = getDocumentElement(element2);
  function cleanup() {
    var _io;
    clearTimeout(timeoutId);
    (_io = io) == null || _io.disconnect();
    io = null;
  }
  function refresh(skip, threshold) {
    if (skip === void 0) {
      skip = false;
    }
    if (threshold === void 0) {
      threshold = 1;
    }
    cleanup();
    const {
      left,
      top,
      width,
      height
    } = element2.getBoundingClientRect();
    if (!skip) {
      onMove();
    }
    if (!width || !height) {
      return;
    }
    const insetTop = floor(top);
    const insetRight = floor(root.clientWidth - (left + width));
    const insetBottom = floor(root.clientHeight - (top + height));
    const insetLeft = floor(left);
    const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px";
    const options = {
      rootMargin,
      threshold: max(0, min(1, threshold)) || 1
    };
    let isFirstUpdate = true;
    function handleObserve(entries) {
      const ratio = entries[0].intersectionRatio;
      if (ratio !== threshold) {
        if (!isFirstUpdate) {
          return refresh();
        }
        if (!ratio) {
          timeoutId = setTimeout(() => {
            refresh(false, 1e-7);
          }, 100);
        } else {
          refresh(false, ratio);
        }
      }
      isFirstUpdate = false;
    }
    try {
      io = new IntersectionObserver(handleObserve, {
        ...options,
        // Handle <iframe>s
        root: root.ownerDocument
      });
    } catch (e) {
      io = new IntersectionObserver(handleObserve, options);
    }
    io.observe(element2);
  }
  refresh(true);
  return cleanup;
}
function autoUpdate(reference, floating, update, options) {
  if (options === void 0) {
    options = {};
  }
  const {
    ancestorScroll = true,
    ancestorResize = true,
    elementResize = typeof ResizeObserver === "function",
    layoutShift = typeof IntersectionObserver === "function",
    animationFrame = false
  } = options;
  const referenceEl = unwrapElement(reference);
  const ancestors = ancestorScroll || ancestorResize ? [...referenceEl ? getOverflowAncestors(referenceEl) : [], ...getOverflowAncestors(floating)] : [];
  ancestors.forEach((ancestor) => {
    ancestorScroll && ancestor.addEventListener("scroll", update, {
      passive: true
    });
    ancestorResize && ancestor.addEventListener("resize", update);
  });
  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;
  let reobserveFrame = -1;
  let resizeObserver2 = null;
  if (elementResize) {
    resizeObserver2 = new ResizeObserver((_ref) => {
      let [firstEntry] = _ref;
      if (firstEntry && firstEntry.target === referenceEl && resizeObserver2) {
        resizeObserver2.unobserve(floating);
        cancelAnimationFrame(reobserveFrame);
        reobserveFrame = requestAnimationFrame(() => {
          var _resizeObserver;
          (_resizeObserver = resizeObserver2) == null || _resizeObserver.observe(floating);
        });
      }
      update();
    });
    if (referenceEl && !animationFrame) {
      resizeObserver2.observe(referenceEl);
    }
    resizeObserver2.observe(floating);
  }
  let frameId;
  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;
  if (animationFrame) {
    frameLoop();
  }
  function frameLoop() {
    const nextRefRect = getBoundingClientRect(reference);
    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {
      update();
    }
    prevRefRect = nextRefRect;
    frameId = requestAnimationFrame(frameLoop);
  }
  update();
  return () => {
    var _resizeObserver2;
    ancestors.forEach((ancestor) => {
      ancestorScroll && ancestor.removeEventListener("scroll", update);
      ancestorResize && ancestor.removeEventListener("resize", update);
    });
    cleanupIo == null || cleanupIo();
    (_resizeObserver2 = resizeObserver2) == null || _resizeObserver2.disconnect();
    resizeObserver2 = null;
    if (animationFrame) {
      cancelAnimationFrame(frameId);
    }
  };
}
var shift2 = shift;
var flip2 = flip;
var size2 = size;
var arrow2 = arrow;
var computePosition2 = (reference, floating, options) => {
  const cache = /* @__PURE__ */ new Map();
  const mergedOptions = {
    platform,
    ...options
  };
  const platformWithCache = {
    ...mergedOptions.platform,
    _c: cache
  };
  return computePosition(reference, floating, {
    ...mergedOptions,
    platform: platformWithCache
  });
};

// node_modules/@melt-ui/svelte/dist/internal/actions/floating/action.js
var defaultConfig = {
  strategy: "absolute",
  placement: "top",
  gutter: 5,
  flip: true,
  sameWidth: false,
  overflowPadding: 8
};
var ARROW_TRANSFORM = {
  bottom: "rotate(45deg)",
  left: "rotate(135deg)",
  top: "rotate(225deg)",
  right: "rotate(315deg)"
};
function useFloating(reference, floating, opts = {}) {
  if (!floating || !reference || opts === null)
    return {
      destroy: noop2
    };
  const options = { ...defaultConfig, ...opts };
  const arrowEl = floating.querySelector("[data-arrow=true]");
  const middleware = [];
  if (options.flip) {
    middleware.push(flip2({
      boundary: options.boundary,
      padding: options.overflowPadding
    }));
  }
  const arrowOffset = isHTMLElement(arrowEl) ? arrowEl.offsetHeight / 2 : 0;
  if (options.gutter || options.offset) {
    const data = options.gutter ? { mainAxis: options.gutter } : options.offset;
    if ((data == null ? void 0 : data.mainAxis) != null) {
      data.mainAxis += arrowOffset;
    }
    middleware.push(offset(data));
  }
  middleware.push(shift2({
    boundary: options.boundary,
    crossAxis: options.overlap,
    padding: options.overflowPadding
  }));
  if (arrowEl) {
    middleware.push(arrow2({ element: arrowEl, padding: 8 }));
  }
  middleware.push(size2({
    padding: options.overflowPadding,
    apply({ rects, availableHeight, availableWidth }) {
      if (options.sameWidth) {
        Object.assign(floating.style, {
          width: `${Math.round(rects.reference.width)}px`,
          minWidth: "unset"
        });
      }
      if (options.fitViewport) {
        Object.assign(floating.style, {
          maxWidth: `${availableWidth}px`,
          maxHeight: `${availableHeight}px`
        });
      }
    }
  }));
  function compute() {
    if (!reference || !floating)
      return;
    if (isHTMLElement(reference) && !reference.ownerDocument.documentElement.contains(reference))
      return;
    const { placement, strategy } = options;
    computePosition2(reference, floating, {
      placement,
      middleware,
      strategy
    }).then((data) => {
      const x = Math.round(data.x);
      const y = Math.round(data.y);
      const [side, align] = getSideAndAlignFromPlacement(data.placement);
      floating.setAttribute("data-side", side);
      floating.setAttribute("data-align", align);
      Object.assign(floating.style, {
        position: options.strategy,
        top: `${y}px`,
        left: `${x}px`
      });
      if (isHTMLElement(arrowEl) && data.middlewareData.arrow) {
        const { x: x2, y: y2 } = data.middlewareData.arrow;
        const dir = data.placement.split("-")[0];
        arrowEl.setAttribute("data-side", dir);
        Object.assign(arrowEl.style, {
          position: "absolute",
          left: x2 != null ? `${x2}px` : "",
          top: y2 != null ? `${y2}px` : "",
          [dir]: `calc(100% - ${arrowOffset}px)`,
          transform: ARROW_TRANSFORM[dir],
          backgroundColor: "inherit",
          zIndex: "inherit"
        });
      }
      return data;
    });
  }
  Object.assign(floating.style, {
    position: options.strategy
  });
  return {
    destroy: autoUpdate(reference, floating, compute)
  };
}
function getSideAndAlignFromPlacement(placement) {
  const [side, align = "center"] = placement.split("-");
  return [side, align];
}

// node_modules/tabbable/dist/index.esm.js
var candidateSelectors = ["input:not([inert])", "select:not([inert])", "textarea:not([inert])", "a[href]:not([inert])", "button:not([inert])", "[tabindex]:not(slot):not([inert])", "audio[controls]:not([inert])", "video[controls]:not([inert])", '[contenteditable]:not([contenteditable="false"]):not([inert])', "details>summary:first-of-type:not([inert])", "details:not([inert])"];
var candidateSelector = candidateSelectors.join(",");
var NoElement = typeof Element === "undefined";
var matches = NoElement ? function() {
} : Element.prototype.matches || Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
var getRootNode = !NoElement && Element.prototype.getRootNode ? function(element2) {
  var _element$getRootNode;
  return element2 === null || element2 === void 0 ? void 0 : (_element$getRootNode = element2.getRootNode) === null || _element$getRootNode === void 0 ? void 0 : _element$getRootNode.call(element2);
} : function(element2) {
  return element2 === null || element2 === void 0 ? void 0 : element2.ownerDocument;
};
var isInert = function isInert2(node, lookUp) {
  var _node$getAttribute;
  if (lookUp === void 0) {
    lookUp = true;
  }
  var inertAtt = node === null || node === void 0 ? void 0 : (_node$getAttribute = node.getAttribute) === null || _node$getAttribute === void 0 ? void 0 : _node$getAttribute.call(node, "inert");
  var inert = inertAtt === "" || inertAtt === "true";
  var result = inert || lookUp && node && isInert2(node.parentNode);
  return result;
};
var isContentEditable2 = function isContentEditable3(node) {
  var _node$getAttribute2;
  var attValue = node === null || node === void 0 ? void 0 : (_node$getAttribute2 = node.getAttribute) === null || _node$getAttribute2 === void 0 ? void 0 : _node$getAttribute2.call(node, "contenteditable");
  return attValue === "" || attValue === "true";
};
var getCandidates = function getCandidates2(el, includeContainer, filter) {
  if (isInert(el)) {
    return [];
  }
  var candidates = Array.prototype.slice.apply(el.querySelectorAll(candidateSelector));
  if (includeContainer && matches.call(el, candidateSelector)) {
    candidates.unshift(el);
  }
  candidates = candidates.filter(filter);
  return candidates;
};
var getCandidatesIteratively = function getCandidatesIteratively2(elements, includeContainer, options) {
  var candidates = [];
  var elementsToCheck = Array.from(elements);
  while (elementsToCheck.length) {
    var element2 = elementsToCheck.shift();
    if (isInert(element2, false)) {
      continue;
    }
    if (element2.tagName === "SLOT") {
      var assigned = element2.assignedElements();
      var content = assigned.length ? assigned : element2.children;
      var nestedCandidates = getCandidatesIteratively2(content, true, options);
      if (options.flatten) {
        candidates.push.apply(candidates, nestedCandidates);
      } else {
        candidates.push({
          scopeParent: element2,
          candidates: nestedCandidates
        });
      }
    } else {
      var validCandidate = matches.call(element2, candidateSelector);
      if (validCandidate && options.filter(element2) && (includeContainer || !elements.includes(element2))) {
        candidates.push(element2);
      }
      var shadowRoot = element2.shadowRoot || // check for an undisclosed shadow
      typeof options.getShadowRoot === "function" && options.getShadowRoot(element2);
      var validShadowRoot = !isInert(shadowRoot, false) && (!options.shadowRootFilter || options.shadowRootFilter(element2));
      if (shadowRoot && validShadowRoot) {
        var _nestedCandidates = getCandidatesIteratively2(shadowRoot === true ? element2.children : shadowRoot.children, true, options);
        if (options.flatten) {
          candidates.push.apply(candidates, _nestedCandidates);
        } else {
          candidates.push({
            scopeParent: element2,
            candidates: _nestedCandidates
          });
        }
      } else {
        elementsToCheck.unshift.apply(elementsToCheck, element2.children);
      }
    }
  }
  return candidates;
};
var hasTabIndex = function hasTabIndex2(node) {
  return !isNaN(parseInt(node.getAttribute("tabindex"), 10));
};
var getTabIndex = function getTabIndex2(node) {
  if (!node) {
    throw new Error("No node provided");
  }
  if (node.tabIndex < 0) {
    if ((/^(AUDIO|VIDEO|DETAILS)$/.test(node.tagName) || isContentEditable2(node)) && !hasTabIndex(node)) {
      return 0;
    }
  }
  return node.tabIndex;
};
var getSortOrderTabIndex = function getSortOrderTabIndex2(node, isScope) {
  var tabIndex = getTabIndex(node);
  if (tabIndex < 0 && isScope && !hasTabIndex(node)) {
    return 0;
  }
  return tabIndex;
};
var sortOrderedTabbables = function sortOrderedTabbables2(a, b) {
  return a.tabIndex === b.tabIndex ? a.documentOrder - b.documentOrder : a.tabIndex - b.tabIndex;
};
var isInput = function isInput2(node) {
  return node.tagName === "INPUT";
};
var isHiddenInput = function isHiddenInput2(node) {
  return isInput(node) && node.type === "hidden";
};
var isDetailsWithSummary = function isDetailsWithSummary2(node) {
  var r = node.tagName === "DETAILS" && Array.prototype.slice.apply(node.children).some(function(child) {
    return child.tagName === "SUMMARY";
  });
  return r;
};
var getCheckedRadio = function getCheckedRadio2(nodes, form) {
  for (var i = 0; i < nodes.length; i++) {
    if (nodes[i].checked && nodes[i].form === form) {
      return nodes[i];
    }
  }
};
var isTabbableRadio = function isTabbableRadio2(node) {
  if (!node.name) {
    return true;
  }
  var radioScope = node.form || getRootNode(node);
  var queryRadios = function queryRadios2(name27) {
    return radioScope.querySelectorAll('input[type="radio"][name="' + name27 + '"]');
  };
  var radioSet;
  if (typeof window !== "undefined" && typeof window.CSS !== "undefined" && typeof window.CSS.escape === "function") {
    radioSet = queryRadios(window.CSS.escape(node.name));
  } else {
    try {
      radioSet = queryRadios(node.name);
    } catch (err) {
      console.error("Looks like you have a radio button with a name attribute containing invalid CSS selector characters and need the CSS.escape polyfill: %s", err.message);
      return false;
    }
  }
  var checked = getCheckedRadio(radioSet, node.form);
  return !checked || checked === node;
};
var isRadio = function isRadio2(node) {
  return isInput(node) && node.type === "radio";
};
var isNonTabbableRadio = function isNonTabbableRadio2(node) {
  return isRadio(node) && !isTabbableRadio(node);
};
var isNodeAttached = function isNodeAttached2(node) {
  var _nodeRoot;
  var nodeRoot = node && getRootNode(node);
  var nodeRootHost = (_nodeRoot = nodeRoot) === null || _nodeRoot === void 0 ? void 0 : _nodeRoot.host;
  var attached = false;
  if (nodeRoot && nodeRoot !== node) {
    var _nodeRootHost, _nodeRootHost$ownerDo, _node$ownerDocument;
    attached = !!((_nodeRootHost = nodeRootHost) !== null && _nodeRootHost !== void 0 && (_nodeRootHost$ownerDo = _nodeRootHost.ownerDocument) !== null && _nodeRootHost$ownerDo !== void 0 && _nodeRootHost$ownerDo.contains(nodeRootHost) || node !== null && node !== void 0 && (_node$ownerDocument = node.ownerDocument) !== null && _node$ownerDocument !== void 0 && _node$ownerDocument.contains(node));
    while (!attached && nodeRootHost) {
      var _nodeRoot2, _nodeRootHost2, _nodeRootHost2$ownerD;
      nodeRoot = getRootNode(nodeRootHost);
      nodeRootHost = (_nodeRoot2 = nodeRoot) === null || _nodeRoot2 === void 0 ? void 0 : _nodeRoot2.host;
      attached = !!((_nodeRootHost2 = nodeRootHost) !== null && _nodeRootHost2 !== void 0 && (_nodeRootHost2$ownerD = _nodeRootHost2.ownerDocument) !== null && _nodeRootHost2$ownerD !== void 0 && _nodeRootHost2$ownerD.contains(nodeRootHost));
    }
  }
  return attached;
};
var isZeroArea = function isZeroArea2(node) {
  var _node$getBoundingClie = node.getBoundingClientRect(), width = _node$getBoundingClie.width, height = _node$getBoundingClie.height;
  return width === 0 && height === 0;
};
var isHidden = function isHidden2(node, _ref) {
  var displayCheck = _ref.displayCheck, getShadowRoot = _ref.getShadowRoot;
  if (getComputedStyle(node).visibility === "hidden") {
    return true;
  }
  var isDirectSummary = matches.call(node, "details>summary:first-of-type");
  var nodeUnderDetails = isDirectSummary ? node.parentElement : node;
  if (matches.call(nodeUnderDetails, "details:not([open]) *")) {
    return true;
  }
  if (!displayCheck || displayCheck === "full" || displayCheck === "legacy-full") {
    if (typeof getShadowRoot === "function") {
      var originalNode = node;
      while (node) {
        var parentElement = node.parentElement;
        var rootNode = getRootNode(node);
        if (parentElement && !parentElement.shadowRoot && getShadowRoot(parentElement) === true) {
          return isZeroArea(node);
        } else if (node.assignedSlot) {
          node = node.assignedSlot;
        } else if (!parentElement && rootNode !== node.ownerDocument) {
          node = rootNode.host;
        } else {
          node = parentElement;
        }
      }
      node = originalNode;
    }
    if (isNodeAttached(node)) {
      return !node.getClientRects().length;
    }
    if (displayCheck !== "legacy-full") {
      return true;
    }
  } else if (displayCheck === "non-zero-area") {
    return isZeroArea(node);
  }
  return false;
};
var isDisabledFromFieldset = function isDisabledFromFieldset2(node) {
  if (/^(INPUT|BUTTON|SELECT|TEXTAREA)$/.test(node.tagName)) {
    var parentNode = node.parentElement;
    while (parentNode) {
      if (parentNode.tagName === "FIELDSET" && parentNode.disabled) {
        for (var i = 0; i < parentNode.children.length; i++) {
          var child = parentNode.children.item(i);
          if (child.tagName === "LEGEND") {
            return matches.call(parentNode, "fieldset[disabled] *") ? true : !child.contains(node);
          }
        }
        return true;
      }
      parentNode = parentNode.parentElement;
    }
  }
  return false;
};
var isNodeMatchingSelectorFocusable = function isNodeMatchingSelectorFocusable2(options, node) {
  if (node.disabled || // we must do an inert look up to filter out any elements inside an inert ancestor
  //  because we're limited in the type of selectors we can use in JSDom (see related
  //  note related to `candidateSelectors`)
  isInert(node) || isHiddenInput(node) || isHidden(node, options) || // For a details element with a summary, the summary element gets the focus
  isDetailsWithSummary(node) || isDisabledFromFieldset(node)) {
    return false;
  }
  return true;
};
var isNodeMatchingSelectorTabbable = function isNodeMatchingSelectorTabbable2(options, node) {
  if (isNonTabbableRadio(node) || getTabIndex(node) < 0 || !isNodeMatchingSelectorFocusable(options, node)) {
    return false;
  }
  return true;
};
var isValidShadowRootTabbable = function isValidShadowRootTabbable2(shadowHostNode) {
  var tabIndex = parseInt(shadowHostNode.getAttribute("tabindex"), 10);
  if (isNaN(tabIndex) || tabIndex >= 0) {
    return true;
  }
  return false;
};
var sortByOrder = function sortByOrder2(candidates) {
  var regularTabbables = [];
  var orderedTabbables = [];
  candidates.forEach(function(item, i) {
    var isScope = !!item.scopeParent;
    var element2 = isScope ? item.scopeParent : item;
    var candidateTabindex = getSortOrderTabIndex(element2, isScope);
    var elements = isScope ? sortByOrder2(item.candidates) : element2;
    if (candidateTabindex === 0) {
      isScope ? regularTabbables.push.apply(regularTabbables, elements) : regularTabbables.push(element2);
    } else {
      orderedTabbables.push({
        documentOrder: i,
        tabIndex: candidateTabindex,
        item,
        isScope,
        content: elements
      });
    }
  });
  return orderedTabbables.sort(sortOrderedTabbables).reduce(function(acc, sortable) {
    sortable.isScope ? acc.push.apply(acc, sortable.content) : acc.push(sortable.content);
    return acc;
  }, []).concat(regularTabbables);
};
var tabbable = function tabbable2(container, options) {
  options = options || {};
  var candidates;
  if (options.getShadowRoot) {
    candidates = getCandidatesIteratively([container], options.includeContainer, {
      filter: isNodeMatchingSelectorTabbable.bind(null, options),
      flatten: false,
      getShadowRoot: options.getShadowRoot,
      shadowRootFilter: isValidShadowRootTabbable
    });
  } else {
    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorTabbable.bind(null, options));
  }
  return sortByOrder(candidates);
};
var focusable = function focusable2(container, options) {
  options = options || {};
  var candidates;
  if (options.getShadowRoot) {
    candidates = getCandidatesIteratively([container], options.includeContainer, {
      filter: isNodeMatchingSelectorFocusable.bind(null, options),
      flatten: true,
      getShadowRoot: options.getShadowRoot
    });
  } else {
    candidates = getCandidates(container, options.includeContainer, isNodeMatchingSelectorFocusable.bind(null, options));
  }
  return candidates;
};
var isTabbable = function isTabbable2(node, options) {
  options = options || {};
  if (!node) {
    throw new Error("No node provided");
  }
  if (matches.call(node, candidateSelector) === false) {
    return false;
  }
  return isNodeMatchingSelectorTabbable(options, node);
};
var focusableCandidateSelector = candidateSelectors.concat("iframe").join(",");
var isFocusable = function isFocusable2(node, options) {
  options = options || {};
  if (!node) {
    throw new Error("No node provided");
  }
  if (matches.call(node, focusableCandidateSelector) === false) {
    return false;
  }
  return isNodeMatchingSelectorFocusable(options, node);
};

// node_modules/focus-trap/dist/focus-trap.esm.js
function ownKeys(e, r) {
  var t = Object.keys(e);
  if (Object.getOwnPropertySymbols) {
    var o = Object.getOwnPropertySymbols(e);
    r && (o = o.filter(function(r2) {
      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
    })), t.push.apply(t, o);
  }
  return t;
}
function _objectSpread2(e) {
  for (var r = 1; r < arguments.length; r++) {
    var t = null != arguments[r] ? arguments[r] : {};
    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
      _defineProperty(e, r2, t[r2]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
    });
  }
  return e;
}
function _defineProperty(obj, key, value) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function _toPrimitive(input, hint) {
  if (typeof input !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== void 0) {
    var res = prim.call(input, hint || "default");
    if (typeof res !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return typeof key === "symbol" ? key : String(key);
}
var activeFocusTraps = {
  activateTrap: function activateTrap(trapStack, trap) {
    if (trapStack.length > 0) {
      var activeTrap = trapStack[trapStack.length - 1];
      if (activeTrap !== trap) {
        activeTrap.pause();
      }
    }
    var trapIndex = trapStack.indexOf(trap);
    if (trapIndex === -1) {
      trapStack.push(trap);
    } else {
      trapStack.splice(trapIndex, 1);
      trapStack.push(trap);
    }
  },
  deactivateTrap: function deactivateTrap(trapStack, trap) {
    var trapIndex = trapStack.indexOf(trap);
    if (trapIndex !== -1) {
      trapStack.splice(trapIndex, 1);
    }
    if (trapStack.length > 0) {
      trapStack[trapStack.length - 1].unpause();
    }
  }
};
var isSelectableInput = function isSelectableInput2(node) {
  return node.tagName && node.tagName.toLowerCase() === "input" && typeof node.select === "function";
};
var isEscapeEvent = function isEscapeEvent2(e) {
  return (e === null || e === void 0 ? void 0 : e.key) === "Escape" || (e === null || e === void 0 ? void 0 : e.key) === "Esc" || (e === null || e === void 0 ? void 0 : e.keyCode) === 27;
};
var isTabEvent = function isTabEvent2(e) {
  return (e === null || e === void 0 ? void 0 : e.key) === "Tab" || (e === null || e === void 0 ? void 0 : e.keyCode) === 9;
};
var isKeyForward = function isKeyForward2(e) {
  return isTabEvent(e) && !e.shiftKey;
};
var isKeyBackward = function isKeyBackward2(e) {
  return isTabEvent(e) && e.shiftKey;
};
var delay = function delay2(fn) {
  return setTimeout(fn, 0);
};
var findIndex = function findIndex2(arr, fn) {
  var idx = -1;
  arr.every(function(value, i) {
    if (fn(value)) {
      idx = i;
      return false;
    }
    return true;
  });
  return idx;
};
var valueOrHandler = function valueOrHandler2(value) {
  for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
    params[_key - 1] = arguments[_key];
  }
  return typeof value === "function" ? value.apply(void 0, params) : value;
};
var getActualTarget = function getActualTarget2(event) {
  return event.target.shadowRoot && typeof event.composedPath === "function" ? event.composedPath()[0] : event.target;
};
var internalTrapStack = [];
var createFocusTrap = function createFocusTrap2(elements, userOptions) {
  var doc = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.document) || document;
  var trapStack = (userOptions === null || userOptions === void 0 ? void 0 : userOptions.trapStack) || internalTrapStack;
  var config = _objectSpread2({
    returnFocusOnDeactivate: true,
    escapeDeactivates: true,
    delayInitialFocus: true,
    isKeyForward,
    isKeyBackward
  }, userOptions);
  var state = {
    // containers given to createFocusTrap()
    // @type {Array<HTMLElement>}
    containers: [],
    // list of objects identifying tabbable nodes in `containers` in the trap
    // NOTE: it's possible that a group has no tabbable nodes if nodes get removed while the trap
    //  is active, but the trap should never get to a state where there isn't at least one group
    //  with at least one tabbable node in it (that would lead to an error condition that would
    //  result in an error being thrown)
    // @type {Array<{
    //   container: HTMLElement,
    //   tabbableNodes: Array<HTMLElement>, // empty if none
    //   focusableNodes: Array<HTMLElement>, // empty if none
    //   posTabIndexesFound: boolean,
    //   firstTabbableNode: HTMLElement|undefined,
    //   lastTabbableNode: HTMLElement|undefined,
    //   firstDomTabbableNode: HTMLElement|undefined,
    //   lastDomTabbableNode: HTMLElement|undefined,
    //   nextTabbableNode: (node: HTMLElement, forward: boolean) => HTMLElement|undefined
    // }>}
    containerGroups: [],
    // same order/length as `containers` list
    // references to objects in `containerGroups`, but only those that actually have
    //  tabbable nodes in them
    // NOTE: same order as `containers` and `containerGroups`, but __not necessarily__
    //  the same length
    tabbableGroups: [],
    nodeFocusedBeforeActivation: null,
    mostRecentlyFocusedNode: null,
    active: false,
    paused: false,
    // timer ID for when delayInitialFocus is true and initial focus in this trap
    //  has been delayed during activation
    delayInitialFocusTimer: void 0,
    // the most recent KeyboardEvent for the configured nav key (typically [SHIFT+]TAB), if any
    recentNavEvent: void 0
  };
  var trap;
  var getOption = function getOption2(configOverrideOptions, optionName, configOptionName) {
    return configOverrideOptions && configOverrideOptions[optionName] !== void 0 ? configOverrideOptions[optionName] : config[configOptionName || optionName];
  };
  var findContainerIndex = function findContainerIndex2(element2, event) {
    var composedPath = typeof (event === null || event === void 0 ? void 0 : event.composedPath) === "function" ? event.composedPath() : void 0;
    return state.containerGroups.findIndex(function(_ref) {
      var container = _ref.container, tabbableNodes = _ref.tabbableNodes;
      return container.contains(element2) || // fall back to explicit tabbable search which will take into consideration any
      //  web components if the `tabbableOptions.getShadowRoot` option was used for
      //  the trap, enabling shadow DOM support in tabbable (`Node.contains()` doesn't
      //  look inside web components even if open)
      (composedPath === null || composedPath === void 0 ? void 0 : composedPath.includes(container)) || tabbableNodes.find(function(node) {
        return node === element2;
      });
    });
  };
  var getNodeForOption = function getNodeForOption2(optionName) {
    var optionValue = config[optionName];
    if (typeof optionValue === "function") {
      for (var _len2 = arguments.length, params = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        params[_key2 - 1] = arguments[_key2];
      }
      optionValue = optionValue.apply(void 0, params);
    }
    if (optionValue === true) {
      optionValue = void 0;
    }
    if (!optionValue) {
      if (optionValue === void 0 || optionValue === false) {
        return optionValue;
      }
      throw new Error("`".concat(optionName, "` was specified but was not a node, or did not return a node"));
    }
    var node = optionValue;
    if (typeof optionValue === "string") {
      node = doc.querySelector(optionValue);
      if (!node) {
        throw new Error("`".concat(optionName, "` as selector refers to no known node"));
      }
    }
    return node;
  };
  var getInitialFocusNode = function getInitialFocusNode2() {
    var node = getNodeForOption("initialFocus");
    if (node === false) {
      return false;
    }
    if (node === void 0 || !isFocusable(node, config.tabbableOptions)) {
      if (findContainerIndex(doc.activeElement) >= 0) {
        node = doc.activeElement;
      } else {
        var firstTabbableGroup = state.tabbableGroups[0];
        var firstTabbableNode = firstTabbableGroup && firstTabbableGroup.firstTabbableNode;
        node = firstTabbableNode || getNodeForOption("fallbackFocus");
      }
    }
    if (!node) {
      throw new Error("Your focus-trap needs to have at least one focusable element");
    }
    return node;
  };
  var updateTabbableNodes = function updateTabbableNodes2() {
    state.containerGroups = state.containers.map(function(container) {
      var tabbableNodes = tabbable(container, config.tabbableOptions);
      var focusableNodes = focusable(container, config.tabbableOptions);
      var firstTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[0] : void 0;
      var lastTabbableNode = tabbableNodes.length > 0 ? tabbableNodes[tabbableNodes.length - 1] : void 0;
      var firstDomTabbableNode = focusableNodes.find(function(node) {
        return isTabbable(node);
      });
      var lastDomTabbableNode = focusableNodes.slice().reverse().find(function(node) {
        return isTabbable(node);
      });
      var posTabIndexesFound = !!tabbableNodes.find(function(node) {
        return getTabIndex(node) > 0;
      });
      return {
        container,
        tabbableNodes,
        focusableNodes,
        /** True if at least one node with positive `tabindex` was found in this container. */
        posTabIndexesFound,
        /** First tabbable node in container, __tabindex__ order; `undefined` if none. */
        firstTabbableNode,
        /** Last tabbable node in container, __tabindex__ order; `undefined` if none. */
        lastTabbableNode,
        // NOTE: DOM order is NOT NECESSARILY "document position" order, but figuring that out
        //  would require more than just https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
        //  because that API doesn't work with Shadow DOM as well as it should (@see
        //  https://github.com/whatwg/dom/issues/320) and since this first/last is only needed, so far,
        //  to address an edge case related to positive tabindex support, this seems like a much easier,
        //  "close enough most of the time" alternative for positive tabindexes which should generally
        //  be avoided anyway...
        /** First tabbable node in container, __DOM__ order; `undefined` if none. */
        firstDomTabbableNode,
        /** Last tabbable node in container, __DOM__ order; `undefined` if none. */
        lastDomTabbableNode,
        /**
         * Finds the __tabbable__ node that follows the given node in the specified direction,
         *  in this container, if any.
         * @param {HTMLElement} node
         * @param {boolean} [forward] True if going in forward tab order; false if going
         *  in reverse.
         * @returns {HTMLElement|undefined} The next tabbable node, if any.
         */
        nextTabbableNode: function nextTabbableNode(node) {
          var forward2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : true;
          var nodeIdx = tabbableNodes.indexOf(node);
          if (nodeIdx < 0) {
            if (forward2) {
              return focusableNodes.slice(focusableNodes.indexOf(node) + 1).find(function(el) {
                return isTabbable(el);
              });
            }
            return focusableNodes.slice(0, focusableNodes.indexOf(node)).reverse().find(function(el) {
              return isTabbable(el);
            });
          }
          return tabbableNodes[nodeIdx + (forward2 ? 1 : -1)];
        }
      };
    });
    state.tabbableGroups = state.containerGroups.filter(function(group) {
      return group.tabbableNodes.length > 0;
    });
    if (state.tabbableGroups.length <= 0 && !getNodeForOption("fallbackFocus")) {
      throw new Error("Your focus-trap must have at least one container with at least one tabbable node in it at all times");
    }
    if (state.containerGroups.find(function(g) {
      return g.posTabIndexesFound;
    }) && state.containerGroups.length > 1) {
      throw new Error("At least one node with a positive tabindex was found in one of your focus-trap's multiple containers. Positive tabindexes are only supported in single-container focus-traps.");
    }
  };
  var getActiveElement = function getActiveElement2(el) {
    var activeElement = el.activeElement;
    if (!activeElement) {
      return;
    }
    if (activeElement.shadowRoot && activeElement.shadowRoot.activeElement !== null) {
      return getActiveElement2(activeElement.shadowRoot);
    }
    return activeElement;
  };
  var tryFocus = function tryFocus2(node) {
    if (node === false) {
      return;
    }
    if (node === getActiveElement(document)) {
      return;
    }
    if (!node || !node.focus) {
      tryFocus2(getInitialFocusNode());
      return;
    }
    node.focus({
      preventScroll: !!config.preventScroll
    });
    state.mostRecentlyFocusedNode = node;
    if (isSelectableInput(node)) {
      node.select();
    }
  };
  var getReturnFocusNode = function getReturnFocusNode2(previousActiveElement) {
    var node = getNodeForOption("setReturnFocus", previousActiveElement);
    return node ? node : node === false ? false : previousActiveElement;
  };
  var findNextNavNode = function findNextNavNode2(_ref2) {
    var target = _ref2.target, event = _ref2.event, _ref2$isBackward = _ref2.isBackward, isBackward = _ref2$isBackward === void 0 ? false : _ref2$isBackward;
    target = target || getActualTarget(event);
    updateTabbableNodes();
    var destinationNode = null;
    if (state.tabbableGroups.length > 0) {
      var containerIndex = findContainerIndex(target, event);
      var containerGroup = containerIndex >= 0 ? state.containerGroups[containerIndex] : void 0;
      if (containerIndex < 0) {
        if (isBackward) {
          destinationNode = state.tabbableGroups[state.tabbableGroups.length - 1].lastTabbableNode;
        } else {
          destinationNode = state.tabbableGroups[0].firstTabbableNode;
        }
      } else if (isBackward) {
        var startOfGroupIndex = findIndex(state.tabbableGroups, function(_ref3) {
          var firstTabbableNode = _ref3.firstTabbableNode;
          return target === firstTabbableNode;
        });
        if (startOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target, false))) {
          startOfGroupIndex = containerIndex;
        }
        if (startOfGroupIndex >= 0) {
          var destinationGroupIndex = startOfGroupIndex === 0 ? state.tabbableGroups.length - 1 : startOfGroupIndex - 1;
          var destinationGroup = state.tabbableGroups[destinationGroupIndex];
          destinationNode = getTabIndex(target) >= 0 ? destinationGroup.lastTabbableNode : destinationGroup.lastDomTabbableNode;
        } else if (!isTabEvent(event)) {
          destinationNode = containerGroup.nextTabbableNode(target, false);
        }
      } else {
        var lastOfGroupIndex = findIndex(state.tabbableGroups, function(_ref4) {
          var lastTabbableNode = _ref4.lastTabbableNode;
          return target === lastTabbableNode;
        });
        if (lastOfGroupIndex < 0 && (containerGroup.container === target || isFocusable(target, config.tabbableOptions) && !isTabbable(target, config.tabbableOptions) && !containerGroup.nextTabbableNode(target))) {
          lastOfGroupIndex = containerIndex;
        }
        if (lastOfGroupIndex >= 0) {
          var _destinationGroupIndex = lastOfGroupIndex === state.tabbableGroups.length - 1 ? 0 : lastOfGroupIndex + 1;
          var _destinationGroup = state.tabbableGroups[_destinationGroupIndex];
          destinationNode = getTabIndex(target) >= 0 ? _destinationGroup.firstTabbableNode : _destinationGroup.firstDomTabbableNode;
        } else if (!isTabEvent(event)) {
          destinationNode = containerGroup.nextTabbableNode(target);
        }
      }
    } else {
      destinationNode = getNodeForOption("fallbackFocus");
    }
    return destinationNode;
  };
  var checkPointerDown = function checkPointerDown2(e) {
    var target = getActualTarget(e);
    if (findContainerIndex(target, e) >= 0) {
      return;
    }
    if (valueOrHandler(config.clickOutsideDeactivates, e)) {
      trap.deactivate({
        // NOTE: by setting `returnFocus: false`, deactivate() will do nothing,
        //  which will result in the outside click setting focus to the node
        //  that was clicked (and if not focusable, to "nothing"); by setting
        //  `returnFocus: true`, we'll attempt to re-focus the node originally-focused
        //  on activation (or the configured `setReturnFocus` node), whether the
        //  outside click was on a focusable node or not
        returnFocus: config.returnFocusOnDeactivate
      });
      return;
    }
    if (valueOrHandler(config.allowOutsideClick, e)) {
      return;
    }
    e.preventDefault();
  };
  var checkFocusIn = function checkFocusIn2(event) {
    var target = getActualTarget(event);
    var targetContained = findContainerIndex(target, event) >= 0;
    if (targetContained || target instanceof Document) {
      if (targetContained) {
        state.mostRecentlyFocusedNode = target;
      }
    } else {
      event.stopImmediatePropagation();
      var nextNode;
      var navAcrossContainers = true;
      if (state.mostRecentlyFocusedNode) {
        if (getTabIndex(state.mostRecentlyFocusedNode) > 0) {
          var mruContainerIdx = findContainerIndex(state.mostRecentlyFocusedNode);
          var tabbableNodes = state.containerGroups[mruContainerIdx].tabbableNodes;
          if (tabbableNodes.length > 0) {
            var mruTabIdx = tabbableNodes.findIndex(function(node) {
              return node === state.mostRecentlyFocusedNode;
            });
            if (mruTabIdx >= 0) {
              if (config.isKeyForward(state.recentNavEvent)) {
                if (mruTabIdx + 1 < tabbableNodes.length) {
                  nextNode = tabbableNodes[mruTabIdx + 1];
                  navAcrossContainers = false;
                }
              } else {
                if (mruTabIdx - 1 >= 0) {
                  nextNode = tabbableNodes[mruTabIdx - 1];
                  navAcrossContainers = false;
                }
              }
            }
          }
        } else {
          if (!state.containerGroups.some(function(g) {
            return g.tabbableNodes.some(function(n) {
              return getTabIndex(n) > 0;
            });
          })) {
            navAcrossContainers = false;
          }
        }
      } else {
        navAcrossContainers = false;
      }
      if (navAcrossContainers) {
        nextNode = findNextNavNode({
          // move FROM the MRU node, not event-related node (which will be the node that is
          //  outside the trap causing the focus escape we're trying to fix)
          target: state.mostRecentlyFocusedNode,
          isBackward: config.isKeyBackward(state.recentNavEvent)
        });
      }
      if (nextNode) {
        tryFocus(nextNode);
      } else {
        tryFocus(state.mostRecentlyFocusedNode || getInitialFocusNode());
      }
    }
    state.recentNavEvent = void 0;
  };
  var checkKeyNav = function checkKeyNav2(event) {
    var isBackward = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
    state.recentNavEvent = event;
    var destinationNode = findNextNavNode({
      event,
      isBackward
    });
    if (destinationNode) {
      if (isTabEvent(event)) {
        event.preventDefault();
      }
      tryFocus(destinationNode);
    }
  };
  var checkKey = function checkKey2(event) {
    if (isEscapeEvent(event) && valueOrHandler(config.escapeDeactivates, event) !== false) {
      event.preventDefault();
      trap.deactivate();
      return;
    }
    if (config.isKeyForward(event) || config.isKeyBackward(event)) {
      checkKeyNav(event, config.isKeyBackward(event));
    }
  };
  var checkClick = function checkClick2(e) {
    var target = getActualTarget(e);
    if (findContainerIndex(target, e) >= 0) {
      return;
    }
    if (valueOrHandler(config.clickOutsideDeactivates, e)) {
      return;
    }
    if (valueOrHandler(config.allowOutsideClick, e)) {
      return;
    }
    e.preventDefault();
    e.stopImmediatePropagation();
  };
  var addListeners = function addListeners2() {
    if (!state.active) {
      return;
    }
    activeFocusTraps.activateTrap(trapStack, trap);
    state.delayInitialFocusTimer = config.delayInitialFocus ? delay(function() {
      tryFocus(getInitialFocusNode());
    }) : tryFocus(getInitialFocusNode());
    doc.addEventListener("focusin", checkFocusIn, true);
    doc.addEventListener("mousedown", checkPointerDown, {
      capture: true,
      passive: false
    });
    doc.addEventListener("touchstart", checkPointerDown, {
      capture: true,
      passive: false
    });
    doc.addEventListener("click", checkClick, {
      capture: true,
      passive: false
    });
    doc.addEventListener("keydown", checkKey, {
      capture: true,
      passive: false
    });
    return trap;
  };
  var removeListeners = function removeListeners2() {
    if (!state.active) {
      return;
    }
    doc.removeEventListener("focusin", checkFocusIn, true);
    doc.removeEventListener("mousedown", checkPointerDown, true);
    doc.removeEventListener("touchstart", checkPointerDown, true);
    doc.removeEventListener("click", checkClick, true);
    doc.removeEventListener("keydown", checkKey, true);
    return trap;
  };
  var checkDomRemoval = function checkDomRemoval2(mutations) {
    var isFocusedNodeRemoved = mutations.some(function(mutation) {
      var removedNodes = Array.from(mutation.removedNodes);
      return removedNodes.some(function(node) {
        return node === state.mostRecentlyFocusedNode;
      });
    });
    if (isFocusedNodeRemoved) {
      tryFocus(getInitialFocusNode());
    }
  };
  var mutationObserver = typeof window !== "undefined" && "MutationObserver" in window ? new MutationObserver(checkDomRemoval) : void 0;
  var updateObservedNodes = function updateObservedNodes2() {
    if (!mutationObserver) {
      return;
    }
    mutationObserver.disconnect();
    if (state.active && !state.paused) {
      state.containers.map(function(container) {
        mutationObserver.observe(container, {
          subtree: true,
          childList: true
        });
      });
    }
  };
  trap = {
    get active() {
      return state.active;
    },
    get paused() {
      return state.paused;
    },
    activate: function activate(activateOptions) {
      if (state.active) {
        return this;
      }
      var onActivate = getOption(activateOptions, "onActivate");
      var onPostActivate = getOption(activateOptions, "onPostActivate");
      var checkCanFocusTrap = getOption(activateOptions, "checkCanFocusTrap");
      if (!checkCanFocusTrap) {
        updateTabbableNodes();
      }
      state.active = true;
      state.paused = false;
      state.nodeFocusedBeforeActivation = doc.activeElement;
      onActivate === null || onActivate === void 0 || onActivate();
      var finishActivation = function finishActivation2() {
        if (checkCanFocusTrap) {
          updateTabbableNodes();
        }
        addListeners();
        updateObservedNodes();
        onPostActivate === null || onPostActivate === void 0 || onPostActivate();
      };
      if (checkCanFocusTrap) {
        checkCanFocusTrap(state.containers.concat()).then(finishActivation, finishActivation);
        return this;
      }
      finishActivation();
      return this;
    },
    deactivate: function deactivate(deactivateOptions) {
      if (!state.active) {
        return this;
      }
      var options = _objectSpread2({
        onDeactivate: config.onDeactivate,
        onPostDeactivate: config.onPostDeactivate,
        checkCanReturnFocus: config.checkCanReturnFocus
      }, deactivateOptions);
      clearTimeout(state.delayInitialFocusTimer);
      state.delayInitialFocusTimer = void 0;
      removeListeners();
      state.active = false;
      state.paused = false;
      updateObservedNodes();
      activeFocusTraps.deactivateTrap(trapStack, trap);
      var onDeactivate = getOption(options, "onDeactivate");
      var onPostDeactivate = getOption(options, "onPostDeactivate");
      var checkCanReturnFocus = getOption(options, "checkCanReturnFocus");
      var returnFocus = getOption(options, "returnFocus", "returnFocusOnDeactivate");
      onDeactivate === null || onDeactivate === void 0 || onDeactivate();
      var finishDeactivation = function finishDeactivation2() {
        delay(function() {
          if (returnFocus) {
            tryFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation));
          }
          onPostDeactivate === null || onPostDeactivate === void 0 || onPostDeactivate();
        });
      };
      if (returnFocus && checkCanReturnFocus) {
        checkCanReturnFocus(getReturnFocusNode(state.nodeFocusedBeforeActivation)).then(finishDeactivation, finishDeactivation);
        return this;
      }
      finishDeactivation();
      return this;
    },
    pause: function pause(pauseOptions) {
      if (state.paused || !state.active) {
        return this;
      }
      var onPause = getOption(pauseOptions, "onPause");
      var onPostPause = getOption(pauseOptions, "onPostPause");
      state.paused = true;
      onPause === null || onPause === void 0 || onPause();
      removeListeners();
      updateObservedNodes();
      onPostPause === null || onPostPause === void 0 || onPostPause();
      return this;
    },
    unpause: function unpause(unpauseOptions) {
      if (!state.paused || !state.active) {
        return this;
      }
      var onUnpause = getOption(unpauseOptions, "onUnpause");
      var onPostUnpause = getOption(unpauseOptions, "onPostUnpause");
      state.paused = false;
      onUnpause === null || onUnpause === void 0 || onUnpause();
      updateTabbableNodes();
      addListeners();
      updateObservedNodes();
      onPostUnpause === null || onPostUnpause === void 0 || onPostUnpause();
      return this;
    },
    updateContainerElements: function updateContainerElements(containerElements) {
      var elementsAsArray = [].concat(containerElements).filter(Boolean);
      state.containers = elementsAsArray.map(function(element2) {
        return typeof element2 === "string" ? doc.querySelector(element2) : element2;
      });
      if (state.active) {
        updateTabbableNodes();
      }
      updateObservedNodes();
      return this;
    }
  };
  trap.updateContainerElements(elements);
  return trap;
};

// node_modules/@melt-ui/svelte/dist/internal/actions/focus-trap/action.js
function createFocusTrap3(config = {}) {
  let trap;
  const { immediate, ...focusTrapOptions } = config;
  const hasFocus = writable(false);
  const isPaused = writable(false);
  const activate = (opts) => trap == null ? void 0 : trap.activate(opts);
  const deactivate = (opts) => {
    trap == null ? void 0 : trap.deactivate(opts);
  };
  const pause = () => {
    if (trap) {
      trap.pause();
      isPaused.set(true);
    }
  };
  const unpause = () => {
    if (trap) {
      trap.unpause();
      isPaused.set(false);
    }
  };
  const useFocusTrap = (node) => {
    trap = createFocusTrap(node, {
      ...focusTrapOptions,
      onActivate() {
        var _a;
        hasFocus.set(true);
        (_a = config.onActivate) == null ? void 0 : _a.call(config);
      },
      onDeactivate() {
        var _a;
        hasFocus.set(false);
        (_a = config.onDeactivate) == null ? void 0 : _a.call(config);
      }
    });
    if (immediate) {
      activate();
    }
    return {
      destroy() {
        deactivate();
        trap = void 0;
      }
    };
  };
  return {
    useFocusTrap,
    hasFocus: readonly(hasFocus),
    isPaused: readonly(isPaused),
    activate,
    deactivate,
    pause,
    unpause
  };
}

// node_modules/@melt-ui/svelte/dist/internal/actions/melt/index.js
function melt(node, params) {
  throw new Error("[MELTUI ERROR]: The `use:melt` action cannot be used without MeltUI's Preprocessor. See: https://www.melt-ui.com/docs/preprocessor");
}

// node_modules/@melt-ui/svelte/dist/internal/actions/modal/action.js
var visibleModals = [];
function useModal(node, config) {
  let unsubInteractOutside = noop2;
  function removeNodeFromVisibleModals() {
    const index = visibleModals.indexOf(node);
    if (index >= 0) {
      visibleModals.splice(index, 1);
    }
  }
  function update(config2) {
    unsubInteractOutside();
    const { open, onClose, shouldCloseOnInteractOutside, closeOnInteractOutside } = config2;
    sleep(100).then(() => {
      if (open) {
        visibleModals.push(node);
      } else {
        removeNodeFromVisibleModals();
      }
    });
    function isLastModal() {
      return last(visibleModals) === node;
    }
    function closeModal() {
      if (isLastModal() && onClose) {
        onClose();
        removeNodeFromVisibleModals();
      }
    }
    function onInteractOutsideStart(e) {
      const target = e.target;
      if (!isElement(target))
        return;
      if (target && isLastModal()) {
        e.preventDefault();
        e.stopPropagation();
        e.stopImmediatePropagation();
      }
    }
    function onInteractOutside(e) {
      if ((shouldCloseOnInteractOutside == null ? void 0 : shouldCloseOnInteractOutside(e)) && isLastModal()) {
        e.preventDefault();
        e.stopPropagation();
        e.stopImmediatePropagation();
        closeModal();
      }
    }
    unsubInteractOutside = useInteractOutside(node, {
      onInteractOutsideStart,
      onInteractOutside: closeOnInteractOutside ? onInteractOutside : void 0,
      enabled: open
    }).destroy;
  }
  update(config);
  return {
    update,
    destroy() {
      removeNodeFromVisibleModals();
      unsubInteractOutside();
    }
  };
}

// node_modules/@melt-ui/svelte/dist/internal/actions/popper/action.js
var defaultConfig2 = {
  floating: {},
  focusTrap: {},
  modal: {},
  escapeKeydown: {},
  portal: "body"
};
var usePopper = (popperElement, args) => {
  popperElement.dataset.escapee = "";
  const { anchorElement, open, options } = args;
  if (!anchorElement || !open || !options) {
    return { destroy: noop2 };
  }
  const opts = { ...defaultConfig2, ...options };
  const callbacks = [];
  if (opts.portal !== null) {
    const portal = usePortal(popperElement, opts.portal);
    if (portal == null ? void 0 : portal.destroy) {
      callbacks.push(portal.destroy);
    }
  }
  callbacks.push(useFloating(anchorElement, popperElement, opts.floating).destroy);
  if (opts.focusTrap !== null) {
    const { useFocusTrap } = createFocusTrap3({
      immediate: true,
      escapeDeactivates: false,
      allowOutsideClick: true,
      returnFocusOnDeactivate: false,
      fallbackFocus: popperElement,
      ...opts.focusTrap
    });
    const usedFocusTrap = useFocusTrap(popperElement);
    if (usedFocusTrap == null ? void 0 : usedFocusTrap.destroy) {
      callbacks.push(usedFocusTrap.destroy);
    }
  }
  if (opts.modal !== null) {
    callbacks.push(useModal(popperElement, {
      onClose: () => {
        if (isHTMLElement(anchorElement)) {
          open.set(false);
          anchorElement.focus();
        }
      },
      shouldCloseOnInteractOutside: (e) => {
        if (e.defaultPrevented)
          return false;
        if (isHTMLElement(anchorElement) && anchorElement.contains(e.target)) {
          return false;
        }
        return true;
      },
      ...opts.modal
    }).destroy);
  }
  if (opts.escapeKeydown !== null) {
    callbacks.push(useEscapeKeydown(popperElement, {
      enabled: open,
      handler: () => {
        open.set(false);
      },
      ...opts.escapeKeydown
    }).destroy);
  }
  const unsubscribe = executeCallbacks(...callbacks);
  return {
    destroy() {
      unsubscribe();
    }
  };
};

// node_modules/@melt-ui/svelte/dist/internal/actions/portal.js
var usePortal = (el, target = "body") => {
  let targetEl;
  if (!isHTMLElement(target) && typeof target !== "string") {
    return {
      destroy: noop2
    };
  }
  async function update(newTarget) {
    target = newTarget;
    if (typeof target === "string") {
      targetEl = document.querySelector(target);
      if (targetEl === null) {
        await tick();
        targetEl = document.querySelector(target);
      }
      if (targetEl === null) {
        throw new Error(`No element found matching css selector: "${target}"`);
      }
    } else if (target instanceof HTMLElement) {
      targetEl = target;
    } else {
      throw new TypeError(`Unknown portal target type: ${target === null ? "null" : typeof target}. Allowed types: string (CSS selector) or HTMLElement.`);
    }
    el.dataset.portal = "";
    targetEl.appendChild(el);
    el.hidden = false;
  }
  function destroy() {
    el.remove();
  }
  update(target);
  return {
    update,
    destroy
  };
};

// node_modules/@melt-ui/svelte/dist/internal/actions/interact-outside/action.js
function useInteractOutside(node, config) {
  let unsub = noop2;
  let isPointerDown = false;
  let isPointerDownInside = false;
  let ignoreEmulatedMouseEvents = false;
  function update(config2) {
    unsub();
    const { onInteractOutside, onInteractOutsideStart, enabled } = config2;
    if (!enabled)
      return;
    function onPointerDown(e) {
      if (onInteractOutside && isValidEvent(e, node)) {
        onInteractOutsideStart == null ? void 0 : onInteractOutsideStart(e);
      }
      const target = e.target;
      if (isElement(target) && isOrContainsTarget(node, target)) {
        isPointerDownInside = true;
      }
      isPointerDown = true;
    }
    function triggerInteractOutside(e) {
      onInteractOutside == null ? void 0 : onInteractOutside(e);
    }
    const documentObj = getOwnerDocument(node);
    if (typeof PointerEvent !== "undefined") {
      const onPointerUp = (e) => {
        if (shouldTriggerInteractOutside(e)) {
          triggerInteractOutside(e);
        }
        resetPointerState();
      };
      unsub = executeCallbacks(addEventListener(documentObj, "pointerdown", onPointerDown, true), addEventListener(documentObj, "pointerup", onPointerUp, true));
    } else {
      const onMouseUp = (e) => {
        if (ignoreEmulatedMouseEvents) {
          ignoreEmulatedMouseEvents = false;
        } else if (shouldTriggerInteractOutside(e)) {
          triggerInteractOutside(e);
        }
        resetPointerState();
      };
      const onTouchEnd = (e) => {
        ignoreEmulatedMouseEvents = true;
        if (shouldTriggerInteractOutside(e)) {
          triggerInteractOutside(e);
        }
        resetPointerState();
      };
      unsub = executeCallbacks(addEventListener(documentObj, "mousedown", onPointerDown, true), addEventListener(documentObj, "mouseup", onMouseUp, true), addEventListener(documentObj, "touchstart", onPointerDown, true), addEventListener(documentObj, "touchend", onTouchEnd, true));
    }
  }
  function shouldTriggerInteractOutside(e) {
    if (isPointerDown && !isPointerDownInside && isValidEvent(e, node)) {
      return true;
    }
    return false;
  }
  function resetPointerState() {
    isPointerDown = false;
    isPointerDownInside = false;
  }
  update(config);
  return {
    update,
    destroy: unsub
  };
}
function isValidEvent(e, node) {
  if ("button" in e && e.button > 0)
    return false;
  const target = e.target;
  if (!isElement(target))
    return false;
  const ownerDocument = target.ownerDocument;
  if (!ownerDocument || !ownerDocument.documentElement.contains(target)) {
    return false;
  }
  return node && !isOrContainsTarget(node, target);
}
function isOrContainsTarget(node, target) {
  return node === target || node.contains(target);
}
function getOwnerDocument(el) {
  return (el == null ? void 0 : el.ownerDocument) ?? document;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/store/toReadableStores.js
function toReadableStores(properties) {
  const result = {};
  Object.keys(properties).forEach((key) => {
    const propertyKey = key;
    const value = properties[propertyKey];
    if (isReadable(value)) {
      result[propertyKey] = withGet(value);
    } else {
      result[propertyKey] = withGet(readable(value));
    }
  });
  return result;
}

// node_modules/@melt-ui/svelte/dist/builders/hidden-input/create.js
var defaults6 = {
  prefix: "",
  disabled: readable(false),
  required: readable(false),
  name: readable(void 0)
};
function createHiddenInput(props) {
  const withDefaults = {
    ...defaults6,
    ...removeUndefined(props)
  };
  const { name: elName } = createElHelpers(withDefaults.prefix);
  const { value, name: name27, disabled, required } = toReadableStores(omit(withDefaults, "prefix"));
  const nameStore = name27;
  const hiddenInput = makeElement(elName("hidden-input"), {
    stores: [value, nameStore, disabled, required],
    returned: ([$value, $name, $disabled, $required]) => {
      return {
        name: $name,
        value: $value == null ? void 0 : $value.toString(),
        "aria-hidden": "true",
        hidden: true,
        disabled: $disabled,
        required: $required,
        tabIndex: -1,
        style: styleToString({
          position: "absolute",
          opacity: 0,
          "pointer-events": "none",
          margin: 0,
          transform: "translateX(-100%)"
        })
      };
    },
    action: (node) => {
      const unsub = value.subscribe((newValue) => {
        node.value = newValue;
        node.dispatchEvent(new Event("change", { bubbles: true }));
      });
      return {
        destroy: unsub
      };
    }
  });
  return hiddenInput;
}

// node_modules/@melt-ui/svelte/dist/builders/label/create.js
function createLabel() {
  const root = makeElement("label", {
    action: (node) => {
      const mouseDown = addMeltEventListener(node, "mousedown", (e) => {
        if (!e.defaultPrevented && e.detail > 1) {
          e.preventDefault();
        }
      });
      return {
        destroy: mouseDown
      };
    }
  });
  return {
    elements: {
      root
    }
  };
}

// node_modules/@melt-ui/svelte/dist/builders/listbox/create.js
var INTERACTION_KEYS = [kbd.ARROW_LEFT, kbd.ESCAPE, kbd.ARROW_RIGHT, kbd.SHIFT, kbd.CAPS_LOCK, kbd.CONTROL, kbd.ALT, kbd.META, kbd.ENTER, kbd.F1, kbd.F2, kbd.F3, kbd.F4, kbd.F5, kbd.F6, kbd.F7, kbd.F8, kbd.F9, kbd.F10, kbd.F11, kbd.F12];
var defaults7 = {
  positioning: {
    placement: "bottom",
    sameWidth: true
  },
  scrollAlignment: "nearest",
  loop: true,
  defaultOpen: false,
  closeOnOutsideClick: true,
  preventScroll: true,
  closeOnEscape: true,
  forceVisible: false,
  portal: void 0,
  builder: "listbox",
  disabled: false,
  required: false,
  name: void 0,
  typeahead: true,
  highlightOnHover: true,
  onOutsideClick: void 0
};
var listboxIdParts = ["trigger", "menu", "label"];
function createListbox(props) {
  const withDefaults = { ...defaults7, ...props };
  const activeTrigger = withGet(writable(null));
  const highlightedItem = withGet(writable(null));
  const selectedWritable = withDefaults.selected ?? writable(withDefaults.defaultSelected);
  const selected = overridable(selectedWritable, withDefaults == null ? void 0 : withDefaults.onSelectedChange);
  const highlighted = derived(highlightedItem, ($highlightedItem) => $highlightedItem ? getOptionProps($highlightedItem) : void 0);
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const open = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const options = toWritableStores({
    ...omit(withDefaults, "open", "defaultOpen", "builder", "ids"),
    multiple: withDefaults.multiple ?? false
  });
  const { scrollAlignment, loop, closeOnOutsideClick, closeOnEscape, preventScroll, portal, forceVisible, positioning, multiple, arrowSize, disabled, required, typeahead, name: nameProp, highlightOnHover, onOutsideClick } = options;
  const { name: name27, selector: selector10 } = createElHelpers(withDefaults.builder);
  const ids = toWritableStores({ ...generateIds(listboxIdParts), ...withDefaults.ids });
  const { handleTypeaheadSearch } = createTypeaheadSearch({
    onMatch: (element2) => {
      highlightedItem.set(element2);
      element2.scrollIntoView({ block: scrollAlignment.get() });
    },
    getCurrentItem() {
      return highlightedItem.get();
    }
  });
  function getOptionProps(el) {
    const value = el.getAttribute("data-value");
    const label2 = el.getAttribute("data-label");
    const disabled2 = el.hasAttribute("data-disabled");
    return {
      value: value ? JSON.parse(value) : value,
      label: label2 ?? el.textContent ?? void 0,
      disabled: disabled2 ? true : false
    };
  }
  const setOption = (newOption) => {
    selected.update(($option) => {
      const $multiple = multiple.get();
      if ($multiple) {
        const optionArr = Array.isArray($option) ? [...$option] : [];
        return toggle(newOption, optionArr, (itemA, itemB) => dequal(itemA.value, itemB.value));
      }
      return newOption;
    });
  };
  function selectItem(item) {
    const props2 = getOptionProps(item);
    setOption(props2);
  }
  async function openMenu() {
    open.set(true);
    const triggerEl = document.getElementById(ids.trigger.get());
    if (!triggerEl)
      return;
    activeTrigger.set(triggerEl);
    await tick();
    const menuElement = document.getElementById(ids.menu.get());
    if (!isHTMLElement(menuElement))
      return;
    const selectedItem = menuElement.querySelector("[aria-selected=true]");
    if (!isHTMLElement(selectedItem))
      return;
    highlightedItem.set(selectedItem);
  }
  function closeMenu() {
    open.set(false);
    highlightedItem.set(null);
  }
  const isVisible = derivedVisible({ open, forceVisible, activeTrigger });
  const isSelected = derived([selected], ([$selected]) => {
    return (value) => {
      if (Array.isArray($selected)) {
        return $selected.some((o) => dequal(o.value, value));
      }
      if (isObject(value)) {
        return dequal($selected == null ? void 0 : $selected.value, stripValues(value, void 0, true));
      }
      return dequal($selected == null ? void 0 : $selected.value, value);
    };
  });
  const isHighlighted = derived([highlighted], ([$value]) => {
    return (item) => {
      return dequal($value == null ? void 0 : $value.value, item);
    };
  });
  const trigger = makeElement(name27("trigger"), {
    stores: [open, highlightedItem, disabled, ids.menu, ids.trigger, ids.label],
    returned: ([$open, $highlightedItem, $disabled, $menuId, $triggerId, $labelId]) => {
      return {
        "aria-activedescendant": $highlightedItem == null ? void 0 : $highlightedItem.id,
        "aria-autocomplete": "list",
        "aria-controls": $menuId,
        "aria-expanded": $open,
        "aria-labelledby": $labelId,
        // autocomplete: 'off',
        id: $triggerId,
        role: "combobox",
        disabled: disabledAttr($disabled),
        type: withDefaults.builder === "select" ? "button" : void 0
      };
    },
    action: (node) => {
      const isInput3 = isHTMLInputElement(node);
      const unsubscribe = executeCallbacks(
        addMeltEventListener(node, "click", () => {
          node.focus();
          const $open = open.get();
          if ($open) {
            closeMenu();
          } else {
            openMenu();
          }
        }),
        // Handle all input key events including typing, meta, and navigation.
        addMeltEventListener(node, "keydown", (e) => {
          const $open = open.get();
          if (!$open) {
            if (INTERACTION_KEYS.includes(e.key)) {
              return;
            }
            if (e.key === kbd.TAB) {
              return;
            }
            if (e.key === kbd.BACKSPACE && isInput3 && node.value === "") {
              return;
            }
            if (e.key === kbd.SPACE && isHTMLButtonElement(node)) {
              return;
            }
            openMenu();
            tick().then(() => {
              const $selectedItem = selected.get();
              if ($selectedItem)
                return;
              const menuEl = document.getElementById(ids.menu.get());
              if (!isHTMLElement(menuEl))
                return;
              const enabledItems = Array.from(menuEl.querySelectorAll(`${selector10("item")}:not([data-disabled]):not([data-hidden])`)).filter((item) => isHTMLElement(item));
              if (!enabledItems.length)
                return;
              if (e.key === kbd.ARROW_DOWN) {
                highlightedItem.set(enabledItems[0]);
                enabledItems[0].scrollIntoView({ block: scrollAlignment.get() });
              } else if (e.key === kbd.ARROW_UP) {
                highlightedItem.set(last(enabledItems));
                last(enabledItems).scrollIntoView({ block: scrollAlignment.get() });
              }
            });
          }
          if (e.key === kbd.TAB) {
            closeMenu();
            return;
          }
          if (e.key === kbd.ENTER || e.key === kbd.SPACE && isHTMLButtonElement(node)) {
            e.preventDefault();
            const $highlightedItem = highlightedItem.get();
            if ($highlightedItem) {
              selectItem($highlightedItem);
            }
            if (!multiple.get()) {
              closeMenu();
            }
          }
          if (e.key === kbd.ARROW_UP && e.altKey) {
            closeMenu();
          }
          if (FIRST_LAST_KEYS.includes(e.key)) {
            e.preventDefault();
            const menuElement = document.getElementById(ids.menu.get());
            if (!isHTMLElement(menuElement))
              return;
            const itemElements = getOptions(menuElement);
            if (!itemElements.length)
              return;
            const candidateNodes = itemElements.filter((opt) => !isElementDisabled(opt) && opt.dataset.hidden === void 0);
            const $currentItem = highlightedItem.get();
            const currentIndex = $currentItem ? candidateNodes.indexOf($currentItem) : -1;
            const $loop = loop.get();
            const $scrollAlignment = scrollAlignment.get();
            let nextItem;
            switch (e.key) {
              case kbd.ARROW_DOWN:
                nextItem = next(candidateNodes, currentIndex, $loop);
                break;
              case kbd.ARROW_UP:
                nextItem = prev(candidateNodes, currentIndex, $loop);
                break;
              case kbd.PAGE_DOWN:
                nextItem = forward(candidateNodes, currentIndex, 10, $loop);
                break;
              case kbd.PAGE_UP:
                nextItem = back(candidateNodes, currentIndex, 10, $loop);
                break;
              case kbd.HOME:
                nextItem = candidateNodes[0];
                break;
              case kbd.END:
                nextItem = last(candidateNodes);
                break;
              default:
                return;
            }
            highlightedItem.set(nextItem);
            nextItem == null ? void 0 : nextItem.scrollIntoView({ block: $scrollAlignment });
          } else if (typeahead.get()) {
            const menuEl = document.getElementById(ids.menu.get());
            if (!isHTMLElement(menuEl))
              return;
            handleTypeaheadSearch(e.key, getOptions(menuEl));
          }
        })
      );
      let unsubEscapeKeydown = noop2;
      const escape = useEscapeKeydown(node, {
        handler: closeMenu,
        enabled: derived([open, closeOnEscape], ([$open, $closeOnEscape]) => {
          return $open && $closeOnEscape;
        })
      });
      if (escape && escape.destroy) {
        unsubEscapeKeydown = escape.destroy;
      }
      return {
        destroy() {
          unsubscribe();
          unsubEscapeKeydown();
        }
      };
    }
  });
  const menu = makeElement(name27("menu"), {
    stores: [isVisible, ids.menu],
    returned: ([$isVisible, $menuId]) => {
      return {
        hidden: $isVisible ? void 0 : true,
        id: $menuId,
        role: "listbox",
        style: styleToString({ display: $isVisible ? void 0 : "none" })
      };
    },
    action: (node) => {
      let unsubPopper = noop2;
      const unsubscribe = executeCallbacks(
        // Bind the popper portal to the input element.
        effect([isVisible, portal, closeOnOutsideClick, positioning, activeTrigger], ([$isVisible, $portal, $closeOnOutsideClick, $positioning, $activeTrigger]) => {
          unsubPopper();
          if (!$isVisible || !$activeTrigger)
            return;
          tick().then(() => {
            const ignoreHandler = createClickOutsideIgnore(ids.trigger.get());
            const popper = usePopper(node, {
              anchorElement: $activeTrigger,
              open,
              options: {
                floating: $positioning,
                focusTrap: null,
                modal: {
                  closeOnInteractOutside: $closeOnOutsideClick,
                  onClose: closeMenu,
                  open: $isVisible,
                  shouldCloseOnInteractOutside: (e) => {
                    var _a;
                    (_a = onOutsideClick.get()) == null ? void 0 : _a(e);
                    if (e.defaultPrevented)
                      return false;
                    const target = e.target;
                    if (!isElement(target))
                      return false;
                    if (target === $activeTrigger || $activeTrigger.contains(target)) {
                      return false;
                    }
                    if (ignoreHandler(e))
                      return false;
                    return true;
                  }
                },
                escapeKeydown: null,
                portal: getPortalDestination(node, $portal)
              }
            });
            if (popper && popper.destroy) {
              unsubPopper = popper.destroy;
            }
          });
        })
      );
      return {
        destroy: () => {
          unsubscribe();
          unsubPopper();
        }
      };
    }
  });
  const { elements: { root: labelBuilder } } = createLabel();
  const { action: labelAction } = get_store_value(labelBuilder);
  const label = makeElement(name27("label"), {
    stores: [ids.label, ids.trigger],
    returned: ([$labelId, $triggerId]) => {
      return {
        id: $labelId,
        for: $triggerId
      };
    },
    action: labelAction
  });
  const option = makeElement(name27("option"), {
    stores: [isSelected],
    returned: ([$isSelected]) => (props2) => {
      const selected2 = $isSelected(props2.value);
      return {
        "data-value": JSON.stringify(props2.value),
        "data-label": props2.label,
        "data-disabled": disabledAttr(props2.disabled),
        "aria-disabled": props2.disabled ? true : void 0,
        "aria-selected": selected2,
        "data-selected": selected2 ? "" : void 0,
        id: generateId(),
        role: "option"
      };
    },
    action: (node) => {
      const unsubscribe = executeCallbacks(addMeltEventListener(node, "click", (e) => {
        if (isElementDisabled(node)) {
          e.preventDefault();
          return;
        }
        selectItem(node);
        if (!multiple.get()) {
          closeMenu();
        }
      }), effect(highlightOnHover, ($highlightOnHover) => {
        if (!$highlightOnHover)
          return;
        const unsub = executeCallbacks(addMeltEventListener(node, "mouseover", () => {
          highlightedItem.set(node);
        }), addMeltEventListener(node, "mouseleave", () => {
          highlightedItem.set(null);
        }));
        return unsub;
      }));
      return { destroy: unsubscribe };
    }
  });
  const group = makeElement(name27("group"), {
    returned: () => {
      return (groupId) => ({
        role: "group",
        "aria-labelledby": groupId
      });
    }
  });
  const groupLabel = makeElement(name27("group-label"), {
    returned: () => {
      return (groupId) => ({
        id: groupId
      });
    }
  });
  const hiddenInput = createHiddenInput({
    value: derived([selected], ([$selected]) => {
      const value = Array.isArray($selected) ? $selected.map((o) => o.value) : $selected == null ? void 0 : $selected.value;
      return typeof value === "string" ? value : JSON.stringify(value);
    }),
    name: readonly(nameProp),
    required,
    prefix: withDefaults.builder
  });
  const arrow3 = makeElement(name27("arrow"), {
    stores: arrowSize,
    returned: ($arrowSize) => ({
      "data-arrow": true,
      style: styleToString({
        position: "absolute",
        width: `var(--arrow-size, ${$arrowSize}px)`,
        height: `var(--arrow-size, ${$arrowSize}px)`
      })
    })
  });
  safeOnMount(() => {
    if (!isBrowser)
      return;
    const menuEl = document.getElementById(ids.menu.get());
    const triggerEl = document.getElementById(ids.trigger.get());
    if (triggerEl) {
      activeTrigger.set(triggerEl);
    }
    if (!menuEl)
      return;
    const selectedEl = menuEl.querySelector("[data-selected]");
    if (!isHTMLElement(selectedEl))
      return;
  });
  effect([highlightedItem], ([$highlightedItem]) => {
    if (!isBrowser)
      return;
    const menuElement = document.getElementById(ids.menu.get());
    if (!isHTMLElement(menuElement))
      return;
    getOptions(menuElement).forEach((node) => {
      if (node === $highlightedItem) {
        addHighlight(node);
      } else {
        removeHighlight(node);
      }
    });
  });
  effect([open], ([$open]) => {
    if (!isBrowser)
      return;
    let unsubScroll = noop2;
    if (preventScroll.get() && $open) {
      unsubScroll = removeScroll();
    }
    return () => {
      unsubScroll();
    };
  });
  return {
    ids,
    elements: {
      trigger,
      group,
      option,
      menu,
      groupLabel,
      label,
      hiddenInput,
      arrow: arrow3
    },
    states: {
      open,
      selected,
      highlighted,
      highlightedItem
    },
    helpers: {
      isSelected,
      isHighlighted,
      closeMenu
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/combobox/create.js
var INTERACTION_KEYS2 = [kbd.ARROW_LEFT, kbd.ESCAPE, kbd.ARROW_RIGHT, kbd.SHIFT, kbd.CAPS_LOCK, kbd.CONTROL, kbd.ALT, kbd.META, kbd.ENTER, kbd.F1, kbd.F2, kbd.F3, kbd.F4, kbd.F5, kbd.F6, kbd.F7, kbd.F8, kbd.F9, kbd.F10, kbd.F11, kbd.F12];
var { name: name3 } = createElHelpers("combobox");
function createCombobox(props) {
  const listbox = createListbox({ ...props, builder: "combobox", typeahead: false });
  const inputValue = writable("");
  const touchedInput = writable(false);
  const input = makeElement(name3("input"), {
    stores: [listbox.elements.trigger, inputValue],
    returned: ([$trigger, $inputValue]) => {
      return {
        ...omit($trigger, "action"),
        role: "combobox",
        value: $inputValue,
        autocomplete: "off"
      };
    },
    action: (node) => {
      const unsubscribe = executeCallbacks(
        addMeltEventListener(node, "input", (e) => {
          if (!isHTMLInputElement(e.target) && !isContentEditable(e.target))
            return;
          touchedInput.set(true);
        }),
        // This shouldn't be cancelled ever, so we don't use addMeltEventListener.
        addEventListener(node, "input", (e) => {
          if (isHTMLInputElement(e.target)) {
            inputValue.set(e.target.value);
          }
          if (isContentEditable(e.target)) {
            inputValue.set(e.target.innerText);
          }
        })
      );
      let unsubEscapeKeydown = noop2;
      const escape = useEscapeKeydown(node, {
        handler: () => {
          listbox.helpers.closeMenu();
        }
      });
      if (escape && escape.destroy) {
        unsubEscapeKeydown = escape.destroy;
      }
      const { destroy } = listbox.elements.trigger(node);
      return {
        destroy() {
          destroy == null ? void 0 : destroy();
          unsubscribe();
          unsubEscapeKeydown();
        }
      };
    }
  });
  effect(listbox.states.open, ($open) => {
    if (!$open) {
      touchedInput.set(false);
    }
  });
  return {
    ...listbox,
    elements: {
      ...omit(listbox.elements, "trigger"),
      input
    },
    states: {
      ...listbox.states,
      touchedInput,
      inputValue
    }
  };
}

// node_modules/@melt-ui/svelte/dist/builders/menu/create.js
var SUB_OPEN_KEYS = {
  ltr: [...SELECTION_KEYS, kbd.ARROW_RIGHT],
  rtl: [...SELECTION_KEYS, kbd.ARROW_LEFT]
};
var SUB_CLOSE_KEYS = {
  ltr: [kbd.ARROW_LEFT],
  rtl: [kbd.ARROW_RIGHT]
};
var menuIdParts = ["menu", "trigger"];
var defaults8 = {
  arrowSize: 8,
  positioning: {
    placement: "bottom"
  },
  preventScroll: true,
  closeOnEscape: true,
  closeOnOutsideClick: true,
  portal: void 0,
  loop: false,
  dir: "ltr",
  defaultOpen: false,
  typeahead: true,
  closeOnItemClick: true,
  onOutsideClick: void 0
};
function createMenuBuilder(opts) {
  const { name: name27, selector: selector10 } = createElHelpers(opts.selector);
  const { preventScroll, arrowSize, positioning, closeOnEscape, closeOnOutsideClick, portal, forceVisible, typeahead, loop, closeFocus, disableFocusFirstItem, closeOnItemClick, onOutsideClick } = opts.rootOptions;
  const rootOpen = opts.rootOpen;
  const rootActiveTrigger = opts.rootActiveTrigger;
  const nextFocusable = opts.nextFocusable;
  const prevFocusable = opts.prevFocusable;
  const isUsingKeyboard = withGet.writable(false);
  const lastPointerX = withGet(writable(0));
  const pointerGraceIntent = withGet(writable(null));
  const pointerDir = withGet(writable("right"));
  const currentFocusedItem = withGet(writable(null));
  const pointerMovingToSubmenu = withGet(derived([pointerDir, pointerGraceIntent], ([$pointerDir, $pointerGraceIntent]) => {
    return (e) => {
      const isMovingTowards = $pointerDir === ($pointerGraceIntent == null ? void 0 : $pointerGraceIntent.side);
      return isMovingTowards && isPointerInGraceArea(e, $pointerGraceIntent == null ? void 0 : $pointerGraceIntent.area);
    };
  }));
  const { typed, handleTypeaheadSearch } = createTypeaheadSearch();
  const rootIds = toWritableStores({ ...generateIds(menuIdParts), ...opts.ids });
  const isVisible = derivedVisible({
    open: rootOpen,
    forceVisible,
    activeTrigger: rootActiveTrigger
  });
  const rootMenu = makeElement(name27(), {
    stores: [isVisible, portal, rootIds.menu, rootIds.trigger],
    returned: ([$isVisible, $portal, $rootMenuId, $rootTriggerId]) => {
      return {
        role: "menu",
        hidden: $isVisible ? void 0 : true,
        style: styleToString({
          display: $isVisible ? void 0 : "none"
        }),
        id: $rootMenuId,
        "aria-labelledby": $rootTriggerId,
        "data-state": $isVisible ? "open" : "closed",
        "data-portal": portalAttr($portal),
        tabindex: -1
      };
    },
    action: (node) => {
      let unsubPopper = noop2;
      const unsubDerived = effect([isVisible, rootActiveTrigger, positioning, closeOnOutsideClick, portal, closeOnEscape], ([$isVisible, $rootActiveTrigger, $positioning, $closeOnOutsideClick, $portal, $closeOnEscape]) => {
        unsubPopper();
        if (!$isVisible || !$rootActiveTrigger)
          return;
        tick().then(() => {
          setMeltMenuAttribute(node, selector10);
          const popper = usePopper(node, {
            anchorElement: $rootActiveTrigger,
            open: rootOpen,
            options: {
              floating: $positioning,
              modal: {
                closeOnInteractOutside: $closeOnOutsideClick,
                shouldCloseOnInteractOutside: (e) => {
                  var _a;
                  (_a = onOutsideClick.get()) == null ? void 0 : _a(e);
                  if (e.defaultPrevented)
                    return false;
                  if (isHTMLElement($rootActiveTrigger) && $rootActiveTrigger.contains(e.target)) {
                    return false;
                  }
                  return true;
                },
                onClose: () => {
                  rootOpen.set(false);
                  $rootActiveTrigger.focus();
                },
                open: $isVisible
              },
              portal: getPortalDestination(node, $portal),
              escapeKeydown: $closeOnEscape ? void 0 : null
            }
          });
          if (popper && popper.destroy) {
            unsubPopper = popper.destroy;
          }
        });
      });
      const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => {
        const target = e.target;
        const menuEl = e.currentTarget;
        if (!isHTMLElement(target) || !isHTMLElement(menuEl))
          return;
        const isKeyDownInside = target.closest('[role="menu"]') === menuEl;
        if (!isKeyDownInside)
          return;
        if (FIRST_LAST_KEYS.includes(e.key)) {
          handleMenuNavigation(e, loop.get() ?? false);
        }
        if (e.key === kbd.TAB) {
          e.preventDefault();
          rootOpen.set(false);
          handleTabNavigation(e, nextFocusable, prevFocusable);
          return;
        }
        const isCharacterKey = e.key.length === 1;
        const isModifierKey = e.ctrlKey || e.altKey || e.metaKey;
        if (!isModifierKey && isCharacterKey && typeahead.get() === true) {
          handleTypeaheadSearch(e.key, getMenuItems(menuEl));
        }
      }));
      return {
        destroy() {
          unsubDerived();
          unsubEvents();
          unsubPopper();
        }
      };
    }
  });
  const rootTrigger = makeElement(name27("trigger"), {
    stores: [rootOpen, rootIds.menu, rootIds.trigger],
    returned: ([$rootOpen, $rootMenuId, $rootTriggerId]) => {
      return {
        "aria-controls": $rootMenuId,
        "aria-expanded": $rootOpen,
        "data-state": $rootOpen ? "open" : "closed",
        id: $rootTriggerId,
        tabindex: 0
      };
    },
    action: (node) => {
      applyAttrsIfDisabled(node);
      rootActiveTrigger.update((p) => {
        if (p)
          return p;
        return node;
      });
      const unsub = executeCallbacks(addMeltEventListener(node, "click", (e) => {
        const $rootOpen = rootOpen.get();
        const triggerEl = e.currentTarget;
        if (!isHTMLElement(triggerEl))
          return;
        handleOpen(triggerEl);
        if (!$rootOpen)
          e.preventDefault();
      }), addMeltEventListener(node, "keydown", (e) => {
        const triggerEl = e.currentTarget;
        if (!isHTMLElement(triggerEl))
          return;
        if (!(SELECTION_KEYS.includes(e.key) || e.key === kbd.ARROW_DOWN))
          return;
        e.preventDefault();
        handleOpen(triggerEl);
        const menuId = triggerEl.getAttribute("aria-controls");
        if (!menuId)
          return;
        const menu = document.getElementById(menuId);
        if (!menu)
          return;
        const menuItems = getMenuItems(menu);
        if (!menuItems.length)
          return;
        handleRovingFocus(menuItems[0]);
      }));
      return {
        destroy: unsub
      };
    }
  });
  const rootArrow = makeElement(name27("arrow"), {
    stores: arrowSize,
    returned: ($arrowSize) => ({
      "data-arrow": true,
      style: styleToString({
        position: "absolute",
        width: `var(--arrow-size, ${$arrowSize}px)`,
        height: `var(--arrow-size, ${$arrowSize}px)`
      })
    })
  });
  const overlay = makeElement(name27("overlay"), {
    stores: [isVisible],
    returned: ([$isVisible]) => {
      return {
        hidden: $isVisible ? void 0 : true,
        tabindex: -1,
        style: styleToString({
          display: $isVisible ? void 0 : "none"
        }),
        "aria-hidden": "true",
        "data-state": stateAttr($isVisible)
      };
    },
    action: (node) => {
      let unsubEscapeKeydown = noop2;
      if (closeOnEscape.get()) {
        const escapeKeydown = useEscapeKeydown(node, {
          handler: () => {
            rootOpen.set(false);
            const $rootActiveTrigger = rootActiveTrigger.get();
            if ($rootActiveTrigger)
              $rootActiveTrigger.focus();
          }
        });
        if (escapeKeydown && escapeKeydown.destroy) {
          unsubEscapeKeydown = escapeKeydown.destroy;
        }
      }
      const unsubPortal = effect([portal], ([$portal]) => {
        if ($portal === null)
          return noop2;
        const portalDestination = getPortalDestination(node, $portal);
        if (portalDestination === null)
          return noop2;
        const portalAction = usePortal(node, portalDestination);
        if (portalAction && portalAction.destroy) {
          return portalAction.destroy;
        } else {
          return noop2;
        }
      });
      return {
        destroy() {
          unsubEscapeKeydown();
          unsubPortal();
        }
      };
    }
  });
  const item = makeElement(name27("item"), {
    returned: () => {
      return {
        role: "menuitem",
        tabindex: -1,
        "data-orientation": "vertical"
      };
    },
    action: (node) => {
      setMeltMenuAttribute(node, selector10);
      applyAttrsIfDisabled(node);
      const unsub = executeCallbacks(addMeltEventListener(node, "pointerdown", (e) => {
        const itemEl = e.currentTarget;
        if (!isHTMLElement(itemEl))
          return;
        if (isElementDisabled(itemEl)) {
          e.preventDefault();
          return;
        }
      }), addMeltEventListener(node, "click", (e) => {
        const itemEl = e.currentTarget;
        if (!isHTMLElement(itemEl))
          return;
        if (isElementDisabled(itemEl)) {
          e.preventDefault();
          return;
        }
        if (e.defaultPrevented) {
          handleRovingFocus(itemEl);
          return;
        }
        if (closeOnItemClick.get()) {
          sleep(1).then(() => {
            rootOpen.set(false);
          });
        }
      }), addMeltEventListener(node, "keydown", (e) => {
        onItemKeyDown(e);
      }), addMeltEventListener(node, "pointermove", (e) => {
        onMenuItemPointerMove(e);
      }), addMeltEventListener(node, "pointerleave", (e) => {
        onMenuItemPointerLeave(e);
      }), addMeltEventListener(node, "focusin", (e) => {
        onItemFocusIn(e);
      }), addMeltEventListener(node, "focusout", (e) => {
        onItemFocusOut(e);
      }));
      return {
        destroy: unsub
      };
    }
  });
  const group = makeElement(name27("group"), {
    returned: () => {
      return (groupId) => ({
        role: "group",
        "aria-labelledby": groupId
      });
    }
  });
  const groupLabel = makeElement(name27("group-label"), {
    returned: () => {
      return (groupId) => ({
        id: groupId
      });
    }
  });
  const checkboxItemDefaults = {
    defaultChecked: false,
    disabled: false
  };
  const createCheckboxItem = (props) => {
    const withDefaults = { ...checkboxItemDefaults, ...props };
    const checkedWritable = withDefaults.checked ?? writable(withDefaults.defaultChecked ?? null);
    const checked = overridable(checkedWritable, withDefaults.onCheckedChange);
    const disabled = writable(withDefaults.disabled);
    const checkboxItem = makeElement(name27("checkbox-item"), {
      stores: [checked, disabled],
      returned: ([$checked, $disabled]) => {
        return {
          role: "menuitemcheckbox",
          tabindex: -1,
          "data-orientation": "vertical",
          "aria-checked": isIndeterminate($checked) ? "mixed" : $checked ? "true" : "false",
          "data-disabled": disabledAttr($disabled),
          "data-state": getCheckedState($checked)
        };
      },
      action: (node) => {
        setMeltMenuAttribute(node, selector10);
        applyAttrsIfDisabled(node);
        const unsub = executeCallbacks(addMeltEventListener(node, "pointerdown", (e) => {
          const itemEl = e.currentTarget;
          if (!isHTMLElement(itemEl))
            return;
          if (isElementDisabled(itemEl)) {
            e.preventDefault();
            return;
          }
        }), addMeltEventListener(node, "click", (e) => {
          const itemEl = e.currentTarget;
          if (!isHTMLElement(itemEl))
            return;
          if (isElementDisabled(itemEl)) {
            e.preventDefault();
            return;
          }
          if (e.defaultPrevented) {
            handleRovingFocus(itemEl);
            return;
          }
          checked.update((prev2) => {
            if (isIndeterminate(prev2))
              return true;
            return !prev2;
          });
          if (closeOnItemClick.get()) {
            tick().then(() => {
              rootOpen.set(false);
            });
          }
        }), addMeltEventListener(node, "keydown", (e) => {
          onItemKeyDown(e);
        }), addMeltEventListener(node, "pointermove", (e) => {
          const itemEl = e.currentTarget;
          if (!isHTMLElement(itemEl))
            return;
          if (isElementDisabled(itemEl)) {
            onItemLeave(e);
            return;
          }
          onMenuItemPointerMove(e, itemEl);
        }), addMeltEventListener(node, "pointerleave", (e) => {
          onMenuItemPointerLeave(e);
        }), addMeltEventListener(node, "focusin", (e) => {
          onItemFocusIn(e);
        }), addMeltEventListener(node, "focusout", (e) => {
          onItemFocusOut(e);
        }));
        return {
          destroy: unsub
        };
      }
    });
    const isChecked = derived(checked, ($checked) => $checked === true);
    const _isIndeterminate = derived(checked, ($checked) => $checked === "indeterminate");
    return {
      elements: {
        checkboxItem
      },
      states: {
        checked
      },
      helpers: {
        isChecked,
        isIndeterminate: _isIndeterminate
      },
      options: {
        disabled
      }
    };
  };
  const createMenuRadioGroup = (args = {}) => {
    const valueWritable = args.value ?? writable(args.defaultValue ?? null);
    const value = overridable(valueWritable, args.onValueChange);
    const radioGroup = makeElement(name27("radio-group"), {
      returned: () => ({
        role: "group"
      })
    });
    const radioItemDefaults = {
      disabled: false
    };
    const radioItem = makeElement(name27("radio-item"), {
      stores: [value],
      returned: ([$value]) => {
        return (itemProps) => {
          const { value: itemValue, disabled } = { ...radioItemDefaults, ...itemProps };
          const checked = $value === itemValue;
          return {
            disabled,
            role: "menuitemradio",
            "data-state": checked ? "checked" : "unchecked",
            "aria-checked": checked,
            "data-disabled": disabledAttr(disabled),
            "data-value": itemValue,
            "data-orientation": "vertical",
            tabindex: -1
          };
        };
      },
      action: (node) => {
        setMeltMenuAttribute(node, selector10);
        const unsub = executeCallbacks(addMeltEventListener(node, "pointerdown", (e) => {
          const itemEl = e.currentTarget;
          if (!isHTMLElement(itemEl))
            return;
          const itemValue = node.dataset.value;
          const disabled = node.dataset.disabled;
          if (disabled || itemValue === void 0) {
            e.preventDefault();
            return;
          }
        }), addMeltEventListener(node, "click", (e) => {
          const itemEl = e.currentTarget;
          if (!isHTMLElement(itemEl))
            return;
          const itemValue = node.dataset.value;
          const disabled = node.dataset.disabled;
          if (disabled || itemValue === void 0) {
            e.preventDefault();
            return;
          }
          if (e.defaultPrevented) {
            if (!isHTMLElement(itemEl))
              return;
            handleRovingFocus(itemEl);
            return;
          }
          value.set(itemValue);
          if (closeOnItemClick.get()) {
            tick().then(() => {
              rootOpen.set(false);
            });
          }
        }), addMeltEventListener(node, "keydown", (e) => {
          onItemKeyDown(e);
        }), addMeltEventListener(node, "pointermove", (e) => {
          const itemEl = e.currentTarget;
          if (!isHTMLElement(itemEl))
            return;
          const itemValue = node.dataset.value;
          const disabled = node.dataset.disabled;
          if (disabled || itemValue === void 0) {
            onItemLeave(e);
            return;
          }
          onMenuItemPointerMove(e, itemEl);
        }), addMeltEventListener(node, "pointerleave", (e) => {
          onMenuItemPointerLeave(e);
        }), addMeltEventListener(node, "focusin", (e) => {
          onItemFocusIn(e);
        }), addMeltEventListener(node, "focusout", (e) => {
          onItemFocusOut(e);
        }));
        return {
          destroy: unsub
        };
      }
    });
    const isChecked = derived(value, ($value) => {
      return (itemValue) => {
        return $value === itemValue;
      };
    });
    return {
      elements: {
        radioGroup,
        radioItem
      },
      states: {
        value
      },
      helpers: {
        isChecked
      }
    };
  };
  const { elements: { root: separator } } = createSeparator({
    orientation: "horizontal"
  });
  const subMenuDefaults = {
    ...defaults8,
    disabled: false,
    positioning: {
      placement: "right-start",
      gutter: 8
    }
  };
  const createSubmenu = (args) => {
    const withDefaults = { ...subMenuDefaults, ...args };
    const subOpenWritable = withDefaults.open ?? writable(false);
    const subOpen = overridable(subOpenWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
    const options = toWritableStores(omit(withDefaults, "ids"));
    const { positioning: positioning2, arrowSize: arrowSize2, disabled } = options;
    const subActiveTrigger = withGet(writable(null));
    const subOpenTimer = withGet(writable(null));
    const pointerGraceTimer = withGet(writable(0));
    const subIds = toWritableStores({ ...generateIds(menuIdParts), ...withDefaults.ids });
    safeOnMount(() => {
      const subTrigger2 = document.getElementById(subIds.trigger.get());
      if (subTrigger2) {
        subActiveTrigger.set(subTrigger2);
      }
    });
    const subIsVisible = derivedVisible({
      open: subOpen,
      forceVisible,
      activeTrigger: subActiveTrigger
    });
    const subMenu = makeElement(name27("submenu"), {
      stores: [subIsVisible, subIds.menu, subIds.trigger],
      returned: ([$subIsVisible, $subMenuId, $subTriggerId]) => {
        return {
          role: "menu",
          hidden: $subIsVisible ? void 0 : true,
          style: styleToString({
            display: $subIsVisible ? void 0 : "none"
          }),
          id: $subMenuId,
          "aria-labelledby": $subTriggerId,
          "data-state": $subIsVisible ? "open" : "closed",
          // unit tests fail on `.closest` if the id starts with a number
          // so using a data attribute
          "data-id": $subMenuId,
          tabindex: -1
        };
      },
      action: (node) => {
        let unsubPopper = noop2;
        const unsubDerived = effect([subIsVisible, positioning2], ([$subIsVisible, $positioning]) => {
          unsubPopper();
          if (!$subIsVisible)
            return;
          const activeTrigger = subActiveTrigger.get();
          if (!activeTrigger)
            return;
          tick().then(() => {
            const parentMenuEl = getParentMenu(activeTrigger);
            const popper = usePopper(node, {
              anchorElement: activeTrigger,
              open: subOpen,
              options: {
                floating: $positioning,
                portal: isHTMLElement(parentMenuEl) ? parentMenuEl : void 0,
                modal: null,
                focusTrap: null,
                escapeKeydown: null
              }
            });
            if (popper && popper.destroy) {
              unsubPopper = popper.destroy;
            }
          });
        });
        const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => {
          if (e.key === kbd.ESCAPE) {
            return;
          }
          const target = e.target;
          const menuEl = e.currentTarget;
          if (!isHTMLElement(target) || !isHTMLElement(menuEl))
            return;
          const isKeyDownInside = target.closest('[role="menu"]') === menuEl;
          if (!isKeyDownInside)
            return;
          if (FIRST_LAST_KEYS.includes(e.key)) {
            e.stopImmediatePropagation();
            handleMenuNavigation(e, loop.get() ?? false);
            return;
          }
          const isCloseKey = SUB_CLOSE_KEYS["ltr"].includes(e.key);
          const isModifierKey = e.ctrlKey || e.altKey || e.metaKey;
          const isCharacterKey = e.key.length === 1;
          if (isCloseKey) {
            const $subActiveTrigger = subActiveTrigger.get();
            e.preventDefault();
            subOpen.update(() => {
              if ($subActiveTrigger) {
                handleRovingFocus($subActiveTrigger);
              }
              return false;
            });
            return;
          }
          if (e.key === kbd.TAB) {
            e.preventDefault();
            rootOpen.set(false);
            handleTabNavigation(e, nextFocusable, prevFocusable);
            return;
          }
          if (!isModifierKey && isCharacterKey && typeahead.get() === true) {
            handleTypeaheadSearch(e.key, getMenuItems(menuEl));
          }
        }), addMeltEventListener(node, "pointermove", (e) => {
          onMenuPointerMove(e);
        }), addMeltEventListener(node, "focusout", (e) => {
          const $subActiveTrigger = subActiveTrigger.get();
          if (isUsingKeyboard.get()) {
            const target = e.target;
            const submenuEl = document.getElementById(subIds.menu.get());
            if (!isHTMLElement(submenuEl) || !isHTMLElement(target))
              return;
            if (!submenuEl.contains(target) && target !== $subActiveTrigger) {
              subOpen.set(false);
            }
          } else {
            const menuEl = e.currentTarget;
            const relatedTarget = e.relatedTarget;
            if (!isHTMLElement(relatedTarget) || !isHTMLElement(menuEl))
              return;
            if (!menuEl.contains(relatedTarget) && relatedTarget !== $subActiveTrigger) {
              subOpen.set(false);
            }
          }
        }));
        return {
          destroy() {
            unsubDerived();
            unsubPopper();
            unsubEvents();
          }
        };
      }
    });
    const subTrigger = makeElement(name27("subtrigger"), {
      stores: [subOpen, disabled, subIds.menu, subIds.trigger],
      returned: ([$subOpen, $disabled, $subMenuId, $subTriggerId]) => {
        return {
          role: "menuitem",
          id: $subTriggerId,
          tabindex: -1,
          "aria-controls": $subMenuId,
          "aria-expanded": $subOpen,
          "data-state": $subOpen ? "open" : "closed",
          "data-disabled": disabledAttr($disabled),
          "aria-haspopop": "menu"
        };
      },
      action: (node) => {
        setMeltMenuAttribute(node, selector10);
        applyAttrsIfDisabled(node);
        subActiveTrigger.update((p) => {
          if (p)
            return p;
          return node;
        });
        const unsubTimer = () => {
          clearTimerStore(subOpenTimer);
          window.clearTimeout(pointerGraceTimer.get());
          pointerGraceIntent.set(null);
        };
        const unsubEvents = executeCallbacks(addMeltEventListener(node, "click", (e) => {
          if (e.defaultPrevented)
            return;
          const triggerEl = e.currentTarget;
          if (!isHTMLElement(triggerEl) || isElementDisabled(triggerEl))
            return;
          handleRovingFocus(triggerEl);
          if (!subOpen.get()) {
            subOpen.update((prev2) => {
              const isAlreadyOpen = prev2;
              if (!isAlreadyOpen) {
                subActiveTrigger.set(triggerEl);
                return !prev2;
              }
              return prev2;
            });
          }
        }), addMeltEventListener(node, "keydown", (e) => {
          const $typed = typed.get();
          const triggerEl = e.currentTarget;
          if (!isHTMLElement(triggerEl) || isElementDisabled(triggerEl))
            return;
          const isTypingAhead = $typed.length > 0;
          if (isTypingAhead && e.key === kbd.SPACE)
            return;
          if (SUB_OPEN_KEYS["ltr"].includes(e.key)) {
            if (!subOpen.get()) {
              triggerEl.click();
              e.preventDefault();
              return;
            }
            const menuId = triggerEl.getAttribute("aria-controls");
            if (!menuId)
              return;
            const menuEl = document.getElementById(menuId);
            if (!isHTMLElement(menuEl))
              return;
            const firstItem = getMenuItems(menuEl)[0];
            handleRovingFocus(firstItem);
          }
        }), addMeltEventListener(node, "pointermove", (e) => {
          if (!isMouse(e))
            return;
          onItemEnter(e);
          if (e.defaultPrevented)
            return;
          const triggerEl = e.currentTarget;
          if (!isHTMLElement(triggerEl))
            return;
          if (!isFocusWithinSubmenu(subIds.menu.get())) {
            handleRovingFocus(triggerEl);
          }
          const openTimer = subOpenTimer.get();
          if (!subOpen.get() && !openTimer && !isElementDisabled(triggerEl)) {
            subOpenTimer.set(window.setTimeout(() => {
              subOpen.update(() => {
                subActiveTrigger.set(triggerEl);
                return true;
              });
              clearTimerStore(subOpenTimer);
            }, 100));
          }
        }), addMeltEventListener(node, "pointerleave", (e) => {
          if (!isMouse(e))
            return;
          clearTimerStore(subOpenTimer);
          const submenuEl = document.getElementById(subIds.menu.get());
          const contentRect = submenuEl == null ? void 0 : submenuEl.getBoundingClientRect();
          if (contentRect) {
            const side = submenuEl == null ? void 0 : submenuEl.dataset.side;
            const rightSide = side === "right";
            const bleed = rightSide ? -5 : 5;
            const contentNearEdge = contentRect[rightSide ? "left" : "right"];
            const contentFarEdge = contentRect[rightSide ? "right" : "left"];
            pointerGraceIntent.set({
              area: [
                // Apply a bleed on clientX to ensure that our exit point is
                // consistently within polygon bounds
                { x: e.clientX + bleed, y: e.clientY },
                { x: contentNearEdge, y: contentRect.top },
                { x: contentFarEdge, y: contentRect.top },
                { x: contentFarEdge, y: contentRect.bottom },
                { x: contentNearEdge, y: contentRect.bottom }
              ],
              side
            });
            window.clearTimeout(pointerGraceTimer.get());
            pointerGraceTimer.set(window.setTimeout(() => {
              pointerGraceIntent.set(null);
            }, 300));
          } else {
            onTriggerLeave(e);
            if (e.defaultPrevented)
              return;
            pointerGraceIntent.set(null);
          }
        }), addMeltEventListener(node, "focusout", (e) => {
          const triggerEl = e.currentTarget;
          if (!isHTMLElement(triggerEl))
            return;
          removeHighlight(triggerEl);
          const relatedTarget = e.relatedTarget;
          if (!isHTMLElement(relatedTarget))
            return;
          const menuId = triggerEl.getAttribute("aria-controls");
          if (!menuId)
            return;
          const menu = document.getElementById(menuId);
          if (menu && !menu.contains(relatedTarget)) {
            subOpen.set(false);
          }
        }), addMeltEventListener(node, "focusin", (e) => {
          onItemFocusIn(e);
        }));
        return {
          destroy() {
            unsubTimer();
            unsubEvents();
          }
        };
      }
    });
    const subArrow = makeElement(name27("subarrow"), {
      stores: arrowSize2,
      returned: ($arrowSize) => ({
        "data-arrow": true,
        style: styleToString({
          position: "absolute",
          width: `var(--arrow-size, ${$arrowSize}px)`,
          height: `var(--arrow-size, ${$arrowSize}px)`
        })
      })
    });
    effect([rootOpen], ([$rootOpen]) => {
      if (!$rootOpen) {
        subActiveTrigger.set(null);
        subOpen.set(false);
      }
    });
    effect([pointerGraceIntent], ([$pointerGraceIntent]) => {
      if (!isBrowser || $pointerGraceIntent)
        return;
      window.clearTimeout(pointerGraceTimer.get());
    });
    effect([subOpen], ([$subOpen]) => {
      if (!isBrowser)
        return;
      if ($subOpen && isUsingKeyboard.get()) {
        sleep(1).then(() => {
          const menuEl = document.getElementById(subIds.menu.get());
          if (!menuEl)
            return;
          const menuItems = getMenuItems(menuEl);
          if (!menuItems.length)
            return;
          handleRovingFocus(menuItems[0]);
        });
      }
      if (!$subOpen) {
        const focusedItem = currentFocusedItem.get();
        const subTriggerEl = document.getElementById(subIds.trigger.get());
        if (focusedItem) {
          sleep(1).then(() => {
            const menuEl = document.getElementById(subIds.menu.get());
            if (!menuEl)
              return;
            if (menuEl.contains(focusedItem)) {
              removeHighlight(focusedItem);
            }
          });
        }
        if (!subTriggerEl || document.activeElement === subTriggerEl)
          return;
        removeHighlight(subTriggerEl);
      }
    });
    return {
      ids: subIds,
      elements: {
        subTrigger,
        subMenu,
        subArrow
      },
      states: {
        subOpen
      },
      options
    };
  };
  safeOnMount(() => {
    const triggerEl = document.getElementById(rootIds.trigger.get());
    if (isHTMLElement(triggerEl) && rootOpen.get()) {
      rootActiveTrigger.set(triggerEl);
    }
    const unsubs = [];
    const handlePointer = () => isUsingKeyboard.set(false);
    const handleKeyDown = () => {
      isUsingKeyboard.set(true);
      unsubs.push(executeCallbacks(addEventListener(document, "pointerdown", handlePointer, { capture: true, once: true }), addEventListener(document, "pointermove", handlePointer, { capture: true, once: true })));
    };
    const keydownListener = (e) => {
      if (e.key === kbd.ESCAPE && closeOnEscape.get()) {
        rootOpen.set(false);
        return;
      }
    };
    unsubs.push(addEventListener(document, "keydown", handleKeyDown, { capture: true }));
    unsubs.push(addEventListener(document, "keydown", keydownListener));
    return () => {
      unsubs.forEach((unsub) => unsub());
    };
  });
  effect([rootOpen, currentFocusedItem], ([$rootOpen, $currentFocusedItem]) => {
    if (!$rootOpen && $currentFocusedItem) {
      removeHighlight($currentFocusedItem);
    }
  });
  effect([rootOpen], ([$rootOpen]) => {
    if (!isBrowser)
      return;
    if (!$rootOpen) {
      const $rootActiveTrigger = rootActiveTrigger.get();
      if (!$rootActiveTrigger)
        return;
      const $closeFocus = closeFocus.get();
      if (!$rootOpen && $rootActiveTrigger) {
        handleFocus({ prop: $closeFocus, defaultEl: $rootActiveTrigger });
      }
    }
  });
  effect([rootOpen, preventScroll], ([$rootOpen, $preventScroll]) => {
    if (!isBrowser)
      return;
    const unsubs = [];
    if (opts.removeScroll && $rootOpen && $preventScroll) {
      unsubs.push(removeScroll());
    }
    sleep(1).then(() => {
      const menuEl = document.getElementById(rootIds.menu.get());
      if (menuEl && $rootOpen && isUsingKeyboard.get()) {
        if (disableFocusFirstItem.get()) {
          handleRovingFocus(menuEl);
          return;
        }
        const menuItems = getMenuItems(menuEl);
        if (!menuItems.length)
          return;
        handleRovingFocus(menuItems[0]);
      }
    });
    return () => {
      unsubs.forEach((unsub) => unsub());
    };
  });
  effect(rootOpen, ($rootOpen) => {
    if (!isBrowser)
      return;
    const handlePointer = () => isUsingKeyboard.set(false);
    const handleKeyDown = (e) => {
      isUsingKeyboard.set(true);
      if (e.key === kbd.ESCAPE && $rootOpen && closeOnEscape.get()) {
        rootOpen.set(false);
        return;
      }
    };
    return executeCallbacks(addEventListener(document, "pointerdown", handlePointer, { capture: true, once: true }), addEventListener(document, "pointermove", handlePointer, { capture: true, once: true }), addEventListener(document, "keydown", handleKeyDown, { capture: true }));
  });
  function handleOpen(triggerEl) {
    rootOpen.update((prev2) => {
      const isOpen = !prev2;
      if (isOpen) {
        nextFocusable.set(getNextFocusable(triggerEl));
        prevFocusable.set(getPreviousFocusable(triggerEl));
        rootActiveTrigger.set(triggerEl);
      }
      return isOpen;
    });
  }
  function onItemFocusIn(e) {
    const itemEl = e.currentTarget;
    if (!isHTMLElement(itemEl))
      return;
    const $currentFocusedItem = currentFocusedItem.get();
    if ($currentFocusedItem) {
      removeHighlight($currentFocusedItem);
    }
    addHighlight(itemEl);
    currentFocusedItem.set(itemEl);
  }
  function onItemFocusOut(e) {
    const itemEl = e.currentTarget;
    if (!isHTMLElement(itemEl))
      return;
    removeHighlight(itemEl);
  }
  function onItemEnter(e) {
    if (isPointerMovingToSubmenu(e)) {
      e.preventDefault();
    }
  }
  function onItemLeave(e) {
    if (isPointerMovingToSubmenu(e)) {
      return;
    }
    const target = e.target;
    if (!isHTMLElement(target))
      return;
    const parentMenuEl = getParentMenu(target);
    if (!parentMenuEl)
      return;
    handleRovingFocus(parentMenuEl);
  }
  function onTriggerLeave(e) {
    if (isPointerMovingToSubmenu(e)) {
      e.preventDefault();
    }
  }
  function onMenuPointerMove(e) {
    if (!isMouse(e))
      return;
    const target = e.target;
    const currentTarget = e.currentTarget;
    if (!isHTMLElement(currentTarget) || !isHTMLElement(target))
      return;
    const $lastPointerX = lastPointerX.get();
    const pointerXHasChanged = $lastPointerX !== e.clientX;
    if (currentTarget.contains(target) && pointerXHasChanged) {
      const newDir = e.clientX > $lastPointerX ? "right" : "left";
      pointerDir.set(newDir);
      lastPointerX.set(e.clientX);
    }
  }
  function onMenuItemPointerMove(e, currTarget = null) {
    if (!isMouse(e))
      return;
    onItemEnter(e);
    if (e.defaultPrevented)
      return;
    if (currTarget) {
      handleRovingFocus(currTarget);
      return;
    }
    const currentTarget = e.currentTarget;
    if (!isHTMLElement(currentTarget))
      return;
    handleRovingFocus(currentTarget);
  }
  function onMenuItemPointerLeave(e) {
    if (!isMouse(e))
      return;
    onItemLeave(e);
  }
  function onItemKeyDown(e) {
    const $typed = typed.get();
    const isTypingAhead = $typed.length > 0;
    if (isTypingAhead && e.key === kbd.SPACE) {
      e.preventDefault();
      return;
    }
    if (SELECTION_KEYS.includes(e.key)) {
      e.preventDefault();
      const itemEl = e.currentTarget;
      if (!isHTMLElement(itemEl))
        return;
      itemEl.click();
    }
  }
  function isIndeterminate(checked) {
    return checked === "indeterminate";
  }
  function getCheckedState(checked) {
    return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked";
  }
  function isPointerMovingToSubmenu(e) {
    return pointerMovingToSubmenu.get()(e);
  }
  function getParentMenu(element2) {
    const parentMenuEl = element2.closest('[role="menu"]');
    if (!isHTMLElement(parentMenuEl))
      return null;
    return parentMenuEl;
  }
  return {
    elements: {
      trigger: rootTrigger,
      menu: rootMenu,
      overlay,
      item,
      group,
      groupLabel,
      arrow: rootArrow,
      separator
    },
    builders: {
      createCheckboxItem,
      createSubmenu,
      createMenuRadioGroup
    },
    states: {
      open: rootOpen
    },
    helpers: {
      handleTypeaheadSearch
    },
    ids: rootIds,
    options: opts.rootOptions
  };
}
function handleTabNavigation(e, nextFocusable, prevFocusable) {
  if (e.shiftKey) {
    const $prevFocusable = prevFocusable.get();
    if ($prevFocusable) {
      e.preventDefault();
      sleep(1).then(() => $prevFocusable.focus());
      prevFocusable.set(null);
    }
  } else {
    const $nextFocusable = nextFocusable.get();
    if ($nextFocusable) {
      e.preventDefault();
      sleep(1).then(() => $nextFocusable.focus());
      nextFocusable.set(null);
    }
  }
}
function getMenuItems(menuElement) {
  return Array.from(menuElement.querySelectorAll(`[data-melt-menu-id="${menuElement.id}"]`)).filter((item) => isHTMLElement(item));
}
function applyAttrsIfDisabled(element2) {
  if (!element2 || !isElementDisabled(element2))
    return;
  element2.setAttribute("data-disabled", "");
  element2.setAttribute("aria-disabled", "true");
}
function clearTimerStore(timerStore) {
  if (!isBrowser)
    return;
  const timer = timerStore.get();
  if (timer) {
    window.clearTimeout(timer);
    timerStore.set(null);
  }
}
function isMouse(e) {
  return e.pointerType === "mouse";
}
function setMeltMenuAttribute(element2, selector10) {
  if (!element2)
    return;
  const menuEl = element2.closest(`${selector10()}, ${selector10("submenu")}`);
  if (!isHTMLElement(menuEl))
    return;
  element2.setAttribute("data-melt-menu-id", menuEl.id);
}
function handleMenuNavigation(e, loop) {
  e.preventDefault();
  const currentFocusedItem = document.activeElement;
  const currentTarget = e.currentTarget;
  if (!isHTMLElement(currentFocusedItem) || !isHTMLElement(currentTarget))
    return;
  const menuItems = getMenuItems(currentTarget);
  if (!menuItems.length)
    return;
  const candidateNodes = menuItems.filter((item) => {
    if (item.hasAttribute("data-disabled") || item.getAttribute("disabled") === "true") {
      return false;
    }
    return true;
  });
  const currentIndex = candidateNodes.indexOf(currentFocusedItem);
  let nextIndex;
  switch (e.key) {
    case kbd.ARROW_DOWN:
      if (loop) {
        nextIndex = currentIndex < candidateNodes.length - 1 ? currentIndex + 1 : 0;
      } else {
        nextIndex = currentIndex < candidateNodes.length - 1 ? currentIndex + 1 : currentIndex;
      }
      break;
    case kbd.ARROW_UP:
      if (loop) {
        nextIndex = currentIndex > 0 ? currentIndex - 1 : candidateNodes.length - 1;
      } else {
        nextIndex = currentIndex < 0 ? candidateNodes.length - 1 : currentIndex > 0 ? currentIndex - 1 : 0;
      }
      break;
    case kbd.HOME:
      nextIndex = 0;
      break;
    case kbd.END:
      nextIndex = candidateNodes.length - 1;
      break;
    default:
      return;
  }
  handleRovingFocus(candidateNodes[nextIndex]);
}
function isPointerInGraceArea(e, area) {
  if (!area)
    return false;
  const cursorPos = { x: e.clientX, y: e.clientY };
  return isPointInPolygon(cursorPos, area);
}
function isPointInPolygon(point, polygon) {
  const { x, y } = point;
  let inside = false;
  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
    const xi = polygon[i].x;
    const yi = polygon[i].y;
    const xj = polygon[j].x;
    const yj = polygon[j].y;
    const intersect = yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi;
    if (intersect)
      inside = !inside;
  }
  return inside;
}
function isFocusWithinSubmenu(submenuId) {
  const activeEl = document.activeElement;
  if (!isHTMLElement(activeEl))
    return false;
  const submenuEl = activeEl.closest(`[data-id="${submenuId}"]`);
  return isHTMLElement(submenuEl);
}
function stateAttr(open) {
  return open ? "open" : "closed";
}

// node_modules/@melt-ui/svelte/dist/builders/context-menu/create.js
var defaults9 = {
  arrowSize: 8,
  positioning: {
    placement: "bottom-start"
  },
  preventScroll: true,
  closeOnEscape: true,
  closeOnOutsideClick: true,
  portal: void 0,
  loop: false,
  dir: "ltr",
  defaultOpen: false,
  forceVisible: false,
  typeahead: true,
  disableFocusFirstItem: true,
  closeFocus: void 0,
  closeOnItemClick: true,
  onOutsideClick: void 0
};
var { name: name4, selector: selector2 } = createElHelpers("context-menu");
function createContextMenu(props) {
  const withDefaults = { ...defaults9, ...props };
  const rootOptions = toWritableStores(omit(withDefaults, "ids"));
  const { positioning, closeOnOutsideClick, portal, forceVisible, closeOnEscape, loop } = rootOptions;
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const rootOpen = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const rootActiveTrigger = writable(null);
  const nextFocusable = withGet.writable(null);
  const prevFocusable = withGet.writable(null);
  const { elements, builders, ids, options, helpers, states } = createMenuBuilder({
    rootOpen,
    rootOptions,
    rootActiveTrigger: withGet(rootActiveTrigger),
    nextFocusable: withGet(nextFocusable),
    prevFocusable: withGet(prevFocusable),
    selector: "context-menu",
    removeScroll: true,
    ids: withDefaults.ids
  });
  const { handleTypeaheadSearch } = helpers;
  const point = writable(null);
  const virtual = withGet(derived([point], ([$point]) => {
    if ($point === null)
      return null;
    return {
      getBoundingClientRect: () => DOMRect.fromRect({
        width: 0,
        height: 0,
        ...$point
      })
    };
  }));
  const longPressTimer = withGet.writable(0);
  function handleClickOutside(e) {
    var _a;
    (_a = rootOptions.onOutsideClick.get()) == null ? void 0 : _a(e);
    if (e.defaultPrevented)
      return false;
    const target = e.target;
    if (!(target instanceof Element))
      return false;
    const isClickInsideTrigger = target.closest(`[data-id="${ids.trigger.get()}"]`) !== null;
    if (!isClickInsideTrigger || isLeftClick(e)) {
      return true;
    }
    return false;
  }
  const isVisible = derivedVisible({
    open: rootOpen,
    forceVisible,
    activeTrigger: rootActiveTrigger
  });
  const menu = makeElement(name4(), {
    stores: [isVisible, portal, ids.menu, ids.trigger],
    returned: ([$isVisible, $portal, $menuId, $triggerId]) => {
      return {
        role: "menu",
        hidden: $isVisible ? void 0 : true,
        style: styleToString({
          display: $isVisible ? void 0 : "none"
        }),
        id: $menuId,
        "aria-labelledby": $triggerId,
        "data-state": $isVisible ? "open" : "closed",
        "data-portal": portalAttr($portal),
        tabindex: -1
      };
    },
    action: (node) => {
      let unsubPopper = noop2;
      const unsubDerived = effect([isVisible, rootActiveTrigger, positioning, closeOnOutsideClick, portal, closeOnEscape], ([$isVisible, $rootActiveTrigger, $positioning, $closeOnOutsideClick, $portal, $closeOnEscape]) => {
        unsubPopper();
        if (!$isVisible || !$rootActiveTrigger)
          return;
        tick().then(() => {
          setMeltMenuAttribute(node, selector2);
          const $virtual = virtual.get();
          const popper = usePopper(node, {
            anchorElement: $virtual ? $virtual : $rootActiveTrigger,
            open: rootOpen,
            options: {
              floating: $positioning,
              modal: {
                closeOnInteractOutside: $closeOnOutsideClick,
                onClose: () => {
                  rootOpen.set(false);
                },
                shouldCloseOnInteractOutside: handleClickOutside,
                open: $isVisible
              },
              portal: getPortalDestination(node, $portal),
              escapeKeydown: $closeOnEscape ? void 0 : null
            }
          });
          if (!popper || !popper.destroy)
            return;
          unsubPopper = popper.destroy;
        });
      });
      const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => {
        const target = e.target;
        const menuEl = e.currentTarget;
        if (!isHTMLElement(target) || !isHTMLElement(menuEl))
          return;
        const isKeyDownInside = target.closest("[role='menu']") === menuEl;
        if (!isKeyDownInside)
          return;
        if (FIRST_LAST_KEYS.includes(e.key)) {
          handleMenuNavigation(e, loop.get());
        }
        if (e.key === kbd.TAB) {
          e.preventDefault();
          rootOpen.set(false);
          handleTabNavigation(e, nextFocusable, prevFocusable);
          return;
        }
        const isCharacterKey = e.key.length === 1;
        const isModifierKey = e.ctrlKey || e.altKey || e.metaKey;
        if (!isModifierKey && isCharacterKey) {
          handleTypeaheadSearch(e.key, getMenuItems(menuEl));
        }
      }));
      return {
        destroy() {
          unsubDerived();
          unsubEvents();
          unsubPopper();
        }
      };
    }
  });
  const trigger = makeElement(name4("trigger"), {
    stores: [rootOpen, ids.trigger],
    returned: ([$rootOpen, $triggerId]) => {
      return {
        "data-state": $rootOpen ? "open" : "closed",
        id: $triggerId,
        style: styleToString({
          WebkitTouchCallout: "none"
        }),
        "data-id": $triggerId
      };
    },
    action: (node) => {
      applyAttrsIfDisabled(node);
      const handleOpen = (e) => {
        point.set({
          x: e.clientX,
          y: e.clientY
        });
        nextFocusable.set(getNextFocusable(node));
        prevFocusable.set(getPreviousFocusable(node));
        rootActiveTrigger.set(node);
        rootOpen.set(true);
      };
      const unsubTimer = () => {
        clearTimerStore(longPressTimer);
      };
      const unsub = executeCallbacks(addMeltEventListener(node, "contextmenu", (e) => {
        clearTimerStore(longPressTimer);
        handleOpen(e);
        e.preventDefault();
      }), addMeltEventListener(node, "pointerdown", (e) => {
        if (!isTouchOrPen(e))
          return;
        clearTimerStore(longPressTimer);
        longPressTimer.set(window.setTimeout(() => handleOpen(e), 700));
      }), addMeltEventListener(node, "pointermove", (e) => {
        if (!isTouchOrPen(e))
          return;
        clearTimerStore(longPressTimer);
      }), addMeltEventListener(node, "pointercancel", (e) => {
        if (!isTouchOrPen(e))
          return;
        clearTimerStore(longPressTimer);
      }), addMeltEventListener(node, "pointerup", (e) => {
        if (!isTouchOrPen(e))
          return;
        clearTimerStore(longPressTimer);
      }));
      return {
        destroy() {
          unsubTimer();
          unsub();
        }
      };
    }
  });
  return {
    ids,
    elements: {
      ...elements,
      menu,
      trigger
    },
    states,
    builders,
    options
  };
}
function isTouchOrPen(e) {
  return e.pointerType !== "mouse";
}
function isLeftClick(event) {
  if ("button" in event) {
    return event.button === 0 && event.ctrlKey === false && event.metaKey === false;
  }
  return true;
}

// node_modules/@swc/helpers/esm/_check_private_redeclaration.js
function _check_private_redeclaration(obj, privateCollection) {
  if (privateCollection.has(obj)) {
    throw new TypeError("Cannot initialize the same private elements twice on an object");
  }
}

// node_modules/@swc/helpers/esm/_class_private_field_init.js
function _class_private_field_init(obj, privateMap, value) {
  _check_private_redeclaration(obj, privateMap);
  privateMap.set(obj, value);
}

// node_modules/@internationalized/date/dist/import.mjs
function $2b4dce13dd5a17fa$export$842a2cf37af977e1(amount, numerator) {
  return amount - numerator * Math.floor(amount / numerator);
}
var $3b62074eb05584b2$var$EPOCH = 1721426;
function $3b62074eb05584b2$export$f297eb839006d339(era, year, month, day) {
  year = $3b62074eb05584b2$export$c36e0ecb2d4fa69d(era, year);
  let y1 = year - 1;
  let monthOffset = -2;
  if (month <= 2) monthOffset = 0;
  else if ($3b62074eb05584b2$export$553d7fa8e3805fc0(year)) monthOffset = -1;
  return $3b62074eb05584b2$var$EPOCH - 1 + 365 * y1 + Math.floor(y1 / 4) - Math.floor(y1 / 100) + Math.floor(y1 / 400) + Math.floor((367 * month - 362) / 12 + monthOffset + day);
}
function $3b62074eb05584b2$export$553d7fa8e3805fc0(year) {
  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
}
function $3b62074eb05584b2$export$c36e0ecb2d4fa69d(era, year) {
  return era === "BC" ? 1 - year : year;
}
function $3b62074eb05584b2$export$4475b7e617eb123c(year) {
  let era = "AD";
  if (year <= 0) {
    era = "BC";
    year = 1 - year;
  }
  return [
    era,
    year
  ];
}
var $3b62074eb05584b2$var$daysInMonth = {
  standard: [
    31,
    28,
    31,
    30,
    31,
    30,
    31,
    31,
    30,
    31,
    30,
    31
  ],
  leapyear: [
    31,
    29,
    31,
    30,
    31,
    30,
    31,
    31,
    30,
    31,
    30,
    31
  ]
};
var $3b62074eb05584b2$export$80ee6245ec4f29ec = class {
  fromJulianDay(jd) {
    let jd0 = jd;
    let depoch = jd0 - $3b62074eb05584b2$var$EPOCH;
    let quadricent = Math.floor(depoch / 146097);
    let dqc = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(depoch, 146097);
    let cent = Math.floor(dqc / 36524);
    let dcent = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(dqc, 36524);
    let quad = Math.floor(dcent / 1461);
    let dquad = (0, $2b4dce13dd5a17fa$export$842a2cf37af977e1)(dcent, 1461);
    let yindex = Math.floor(dquad / 365);
    let extendedYear = quadricent * 400 + cent * 100 + quad * 4 + yindex + (cent !== 4 && yindex !== 4 ? 1 : 0);
    let [era, year] = $3b62074eb05584b2$export$4475b7e617eb123c(extendedYear);
    let yearDay = jd0 - $3b62074eb05584b2$export$f297eb839006d339(era, year, 1, 1);
    let leapAdj = 2;
    if (jd0 < $3b62074eb05584b2$export$f297eb839006d339(era, year, 3, 1)) leapAdj = 0;
    else if ($3b62074eb05584b2$export$553d7fa8e3805fc0(year)) leapAdj = 1;
    let month = Math.floor(((yearDay + leapAdj) * 12 + 373) / 367);
    let day = jd0 - $3b62074eb05584b2$export$f297eb839006d339(era, year, month, 1) + 1;
    return new (0, $35ea8db9cb2ccb90$export$99faa760c7908e4f)(era, year, month, day);
  }
  toJulianDay(date) {
    return $3b62074eb05584b2$export$f297eb839006d339(date.era, date.year, date.month, date.day);
  }
  getDaysInMonth(date) {
    return $3b62074eb05584b2$var$daysInMonth[$3b62074eb05584b2$export$553d7fa8e3805fc0(date.year) ? "leapyear" : "standard"][date.month - 1];
  }
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  getMonthsInYear(date) {
    return 12;
  }
  getDaysInYear(date) {
    return $3b62074eb05584b2$export$553d7fa8e3805fc0(date.year) ? 366 : 365;
  }
  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  getYearsInEra(date) {
    return 9999;
  }
  getEras() {
    return [
      "BC",
      "AD"
    ];
  }
  isInverseEra(date) {
    return date.era === "BC";
  }
  balanceDate(date) {
    if (date.year <= 0) {
      date.era = date.era === "BC" ? "AD" : "BC";
      date.year = 1 - date.year;
    }
  }
  constructor() {
    this.identifier = "gregory";
  }
};
var $2fe286d2fb449abb$export$7a5acbd77d414bd9 = {
  "001": 1,
  AD: 1,
  AE: 6,
  AF: 6,
  AI: 1,
  AL: 1,
  AM: 1,
  AN: 1,
  AR: 1,
  AT: 1,
  AU: 1,
  AX: 1,
  AZ: 1,
  BA: 1,
  BE: 1,
  BG: 1,
  BH: 6,
  BM: 1,
  BN: 1,
  BY: 1,
  CH: 1,
  CL: 1,
  CM: 1,
  CN: 1,
  CR: 1,
  CY: 1,
  CZ: 1,
  DE: 1,
  DJ: 6,
  DK: 1,
  DZ: 6,
  EC: 1,
  EE: 1,
  EG: 6,
  ES: 1,
  FI: 1,
  FJ: 1,
  FO: 1,
  FR: 1,
  GB: 1,
  GE: 1,
  GF: 1,
  GP: 1,
  GR: 1,
  HR: 1,
  HU: 1,
  IE: 1,
  IQ: 6,
  IR: 6,
  IS: 1,
  IT: 1,
  JO: 6,
  KG: 1,
  KW: 6,
  KZ: 1,
  LB: 1,
  LI: 1,
  LK: 1,
  LT: 1,
  LU: 1,
  LV: 1,
  LY: 6,
  MC: 1,
  MD: 1,
  ME: 1,
  MK: 1,
  MN: 1,
  MQ: 1,
  MV: 5,
  MY: 1,
  NL: 1,
  NO: 1,
  NZ: 1,
  OM: 6,
  PL: 1,
  QA: 6,
  RE: 1,
  RO: 1,
  RS: 1,
  RU: 1,
  SD: 6,
  SE: 1,
  SI: 1,
  SK: 1,
  SM: 1,
  SY: 6,
  TJ: 1,
  TM: 1,
  TR: 1,
  UA: 1,
  UY: 1,
  UZ: 1,
  VA: 1,
  VN: 1,
  XK: 1
};
function $14e0f24ef4ac5c92$export$ea39ec197993aef0(a, b) {
  b = (0, $11d87f3f76e88657$export$b4a036af3fc0b032)(b, a.calendar);
  return a.era === b.era && a.year === b.year && a.month === b.month && a.day === b.day;
}
function $14e0f24ef4ac5c92$export$a18c89cbd24170ff(a, b) {
  b = (0, $11d87f3f76e88657$export$b4a036af3fc0b032)(b, a.calendar);
  a = $14e0f24ef4ac5c92$export$a5a3b454ada2268e(a);
  b = $14e0f24ef4ac5c92$export$a5a3b454ada2268e(b);
  return a.era === b.era && a.year === b.year && a.month === b.month;
}
function $14e0f24ef4ac5c92$export$629b0a497aa65267(date, timeZone) {
  return $14e0f24ef4ac5c92$export$ea39ec197993aef0(date, $14e0f24ef4ac5c92$export$d0bdf45af03a6ea3(timeZone));
}
function $14e0f24ef4ac5c92$export$2061056d06d7cdf7(date, locale) {
  let julian = date.calendar.toJulianDay(date);
  let dayOfWeek = Math.ceil(julian + 1 - $14e0f24ef4ac5c92$var$getWeekStart(locale)) % 7;
  if (dayOfWeek < 0) dayOfWeek += 7;
  return dayOfWeek;
}
function $14e0f24ef4ac5c92$export$461939dd4422153(timeZone) {
  return (0, $11d87f3f76e88657$export$1b96692a1ba042ac)(Date.now(), timeZone);
}
function $14e0f24ef4ac5c92$export$d0bdf45af03a6ea3(timeZone) {
  return (0, $11d87f3f76e88657$export$93522d1a439f3617)($14e0f24ef4ac5c92$export$461939dd4422153(timeZone));
}
function $14e0f24ef4ac5c92$export$68781ddf31c0090f(a, b) {
  return a.calendar.toJulianDay(a) - b.calendar.toJulianDay(b);
}
function $14e0f24ef4ac5c92$export$c19a80a9721b80f6(a, b) {
  return $14e0f24ef4ac5c92$var$timeToMs(a) - $14e0f24ef4ac5c92$var$timeToMs(b);
}
function $14e0f24ef4ac5c92$var$timeToMs(a) {
  return a.hour * 36e5 + a.minute * 6e4 + a.second * 1e3 + a.millisecond;
}
var $14e0f24ef4ac5c92$var$localTimeZone = null;
function $14e0f24ef4ac5c92$export$aa8b41735afcabd2() {
  if ($14e0f24ef4ac5c92$var$localTimeZone == null) $14e0f24ef4ac5c92$var$localTimeZone = new Intl.DateTimeFormat().resolvedOptions().timeZone;
  return $14e0f24ef4ac5c92$var$localTimeZone;
}
function $14e0f24ef4ac5c92$export$a5a3b454ada2268e(date) {
  return date.subtract({
    days: date.day - 1
  });
}
function $14e0f24ef4ac5c92$export$a2258d9c4118825c(date) {
  return date.add({
    days: date.calendar.getDaysInMonth(date) - date.day
  });
}
var $14e0f24ef4ac5c92$var$cachedRegions = /* @__PURE__ */ new Map();
function $14e0f24ef4ac5c92$var$getRegion(locale) {
  if (Intl.Locale) {
    let region = $14e0f24ef4ac5c92$var$cachedRegions.get(locale);
    if (!region) {
      region = new Intl.Locale(locale).maximize().region;
      if (region) $14e0f24ef4ac5c92$var$cachedRegions.set(locale, region);
    }
    return region;
  }
  let part = locale.split("-")[1];
  return part === "u" ? void 0 : part;
}
function $14e0f24ef4ac5c92$var$getWeekStart(locale) {
  let region = $14e0f24ef4ac5c92$var$getRegion(locale);
  return region ? (0, $2fe286d2fb449abb$export$7a5acbd77d414bd9)[region] || 0 : 0;
}
function $11d87f3f76e88657$export$bd4fb2bc8bb06fb(date) {
  date = $11d87f3f76e88657$export$b4a036af3fc0b032(date, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
  let year = (0, $3b62074eb05584b2$export$c36e0ecb2d4fa69d)(date.era, date.year);
  return $11d87f3f76e88657$var$epochFromParts(year, date.month, date.day, date.hour, date.minute, date.second, date.millisecond);
}
function $11d87f3f76e88657$var$epochFromParts(year, month, day, hour, minute, second, millisecond) {
  let date = /* @__PURE__ */ new Date();
  date.setUTCHours(hour, minute, second, millisecond);
  date.setUTCFullYear(year, month - 1, day);
  return date.getTime();
}
function $11d87f3f76e88657$export$59c99f3515d3493f(ms, timeZone) {
  if (timeZone === "UTC") return 0;
  if (ms > 0 && timeZone === (0, $14e0f24ef4ac5c92$export$aa8b41735afcabd2)()) return new Date(ms).getTimezoneOffset() * -6e4;
  let { year, month, day, hour, minute, second } = $11d87f3f76e88657$var$getTimeZoneParts(ms, timeZone);
  let utc = $11d87f3f76e88657$var$epochFromParts(year, month, day, hour, minute, second, 0);
  return utc - Math.floor(ms / 1e3) * 1e3;
}
var $11d87f3f76e88657$var$formattersByTimeZone = /* @__PURE__ */ new Map();
function $11d87f3f76e88657$var$getTimeZoneParts(ms, timeZone) {
  let formatter = $11d87f3f76e88657$var$formattersByTimeZone.get(timeZone);
  if (!formatter) {
    formatter = new Intl.DateTimeFormat("en-US", {
      timeZone,
      hour12: false,
      era: "short",
      year: "numeric",
      month: "numeric",
      day: "numeric",
      hour: "numeric",
      minute: "numeric",
      second: "numeric"
    });
    $11d87f3f76e88657$var$formattersByTimeZone.set(timeZone, formatter);
  }
  let parts = formatter.formatToParts(new Date(ms));
  let namedParts = {};
  for (let part of parts) if (part.type !== "literal") namedParts[part.type] = part.value;
  return {
    // Firefox returns B instead of BC... https://bugzilla.mozilla.org/show_bug.cgi?id=1752253
    year: namedParts.era === "BC" || namedParts.era === "B" ? -namedParts.year + 1 : +namedParts.year,
    month: +namedParts.month,
    day: +namedParts.day,
    hour: namedParts.hour === "24" ? 0 : +namedParts.hour,
    minute: +namedParts.minute,
    second: +namedParts.second
  };
}
var $11d87f3f76e88657$var$DAYMILLIS = 864e5;
function $11d87f3f76e88657$export$136f38efe7caf549(date, timeZone) {
  let ms = $11d87f3f76e88657$export$bd4fb2bc8bb06fb(date);
  let earlier = ms - $11d87f3f76e88657$export$59c99f3515d3493f(ms - $11d87f3f76e88657$var$DAYMILLIS, timeZone);
  let later = ms - $11d87f3f76e88657$export$59c99f3515d3493f(ms + $11d87f3f76e88657$var$DAYMILLIS, timeZone);
  return $11d87f3f76e88657$var$getValidWallTimes(date, timeZone, earlier, later);
}
function $11d87f3f76e88657$var$getValidWallTimes(date, timeZone, earlier, later) {
  let found = earlier === later ? [
    earlier
  ] : [
    earlier,
    later
  ];
  return found.filter((absolute) => $11d87f3f76e88657$var$isValidWallTime(date, timeZone, absolute));
}
function $11d87f3f76e88657$var$isValidWallTime(date, timeZone, absolute) {
  let parts = $11d87f3f76e88657$var$getTimeZoneParts(absolute, timeZone);
  return date.year === parts.year && date.month === parts.month && date.day === parts.day && date.hour === parts.hour && date.minute === parts.minute && date.second === parts.second;
}
function $11d87f3f76e88657$export$5107c82f94518f5c(date, timeZone, disambiguation = "compatible") {
  let dateTime = $11d87f3f76e88657$export$b21e0b124e224484(date);
  if (timeZone === "UTC") return $11d87f3f76e88657$export$bd4fb2bc8bb06fb(dateTime);
  if (timeZone === (0, $14e0f24ef4ac5c92$export$aa8b41735afcabd2)() && disambiguation === "compatible") {
    dateTime = $11d87f3f76e88657$export$b4a036af3fc0b032(dateTime, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
    let date2 = /* @__PURE__ */ new Date();
    let year = (0, $3b62074eb05584b2$export$c36e0ecb2d4fa69d)(dateTime.era, dateTime.year);
    date2.setFullYear(year, dateTime.month - 1, dateTime.day);
    date2.setHours(dateTime.hour, dateTime.minute, dateTime.second, dateTime.millisecond);
    return date2.getTime();
  }
  let ms = $11d87f3f76e88657$export$bd4fb2bc8bb06fb(dateTime);
  let offsetBefore = $11d87f3f76e88657$export$59c99f3515d3493f(ms - $11d87f3f76e88657$var$DAYMILLIS, timeZone);
  let offsetAfter = $11d87f3f76e88657$export$59c99f3515d3493f(ms + $11d87f3f76e88657$var$DAYMILLIS, timeZone);
  let valid = $11d87f3f76e88657$var$getValidWallTimes(dateTime, timeZone, ms - offsetBefore, ms - offsetAfter);
  if (valid.length === 1) return valid[0];
  if (valid.length > 1) switch (disambiguation) {
    case "compatible":
    case "earlier":
      return valid[0];
    case "later":
      return valid[valid.length - 1];
    case "reject":
      throw new RangeError("Multiple possible absolute times found");
  }
  switch (disambiguation) {
    case "earlier":
      return Math.min(ms - offsetBefore, ms - offsetAfter);
    case "compatible":
    case "later":
      return Math.max(ms - offsetBefore, ms - offsetAfter);
    case "reject":
      throw new RangeError("No such absolute time found");
  }
}
function $11d87f3f76e88657$export$e67a095c620b86fe(dateTime, timeZone, disambiguation = "compatible") {
  return new Date($11d87f3f76e88657$export$5107c82f94518f5c(dateTime, timeZone, disambiguation));
}
function $11d87f3f76e88657$export$1b96692a1ba042ac(ms, timeZone) {
  let offset2 = $11d87f3f76e88657$export$59c99f3515d3493f(ms, timeZone);
  let date = new Date(ms + offset2);
  let year = date.getUTCFullYear();
  let month = date.getUTCMonth() + 1;
  let day = date.getUTCDate();
  let hour = date.getUTCHours();
  let minute = date.getUTCMinutes();
  let second = date.getUTCSeconds();
  let millisecond = date.getUTCMilliseconds();
  return new (0, $35ea8db9cb2ccb90$export$d3b7288e7994edea)(year, month, day, timeZone, offset2, hour, minute, second, millisecond);
}
function $11d87f3f76e88657$export$93522d1a439f3617(dateTime) {
  return new (0, $35ea8db9cb2ccb90$export$99faa760c7908e4f)(dateTime.calendar, dateTime.era, dateTime.year, dateTime.month, dateTime.day);
}
function $11d87f3f76e88657$export$b21e0b124e224484(date, time) {
  let hour = 0, minute = 0, second = 0, millisecond = 0;
  if ("timeZone" in date) ({ hour, minute, second, millisecond } = date);
  else if ("hour" in date && !time) return date;
  if (time) ({ hour, minute, second, millisecond } = time);
  return new (0, $35ea8db9cb2ccb90$export$ca871e8dbb80966f)(date.calendar, date.era, date.year, date.month, date.day, hour, minute, second, millisecond);
}
function $11d87f3f76e88657$export$b4a036af3fc0b032(date, calendar) {
  if (date.calendar.identifier === calendar.identifier) return date;
  let calendarDate = calendar.fromJulianDay(date.calendar.toJulianDay(date));
  let copy = date.copy();
  copy.calendar = calendar;
  copy.era = calendarDate.era;
  copy.year = calendarDate.year;
  copy.month = calendarDate.month;
  copy.day = calendarDate.day;
  (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(copy);
  return copy;
}
function $11d87f3f76e88657$export$84c95a83c799e074(date, timeZone, disambiguation) {
  if (date instanceof (0, $35ea8db9cb2ccb90$export$d3b7288e7994edea)) {
    if (date.timeZone === timeZone) return date;
    return $11d87f3f76e88657$export$538b00033cc11c75(date, timeZone);
  }
  let ms = $11d87f3f76e88657$export$5107c82f94518f5c(date, timeZone, disambiguation);
  return $11d87f3f76e88657$export$1b96692a1ba042ac(ms, timeZone);
}
function $11d87f3f76e88657$export$83aac07b4c37b25(date) {
  let ms = $11d87f3f76e88657$export$bd4fb2bc8bb06fb(date) - date.offset;
  return new Date(ms);
}
function $11d87f3f76e88657$export$538b00033cc11c75(date, timeZone) {
  let ms = $11d87f3f76e88657$export$bd4fb2bc8bb06fb(date) - date.offset;
  return $11d87f3f76e88657$export$b4a036af3fc0b032($11d87f3f76e88657$export$1b96692a1ba042ac(ms, timeZone), date.calendar);
}
var $735220c2d4774dd3$var$ONE_HOUR = 36e5;
function $735220c2d4774dd3$export$e16d8520af44a096(date, duration) {
  let mutableDate = date.copy();
  let days = "hour" in mutableDate ? $735220c2d4774dd3$var$addTimeFields(mutableDate, duration) : 0;
  $735220c2d4774dd3$var$addYears(mutableDate, duration.years || 0);
  if (mutableDate.calendar.balanceYearMonth) mutableDate.calendar.balanceYearMonth(mutableDate, date);
  mutableDate.month += duration.months || 0;
  $735220c2d4774dd3$var$balanceYearMonth(mutableDate);
  $735220c2d4774dd3$var$constrainMonthDay(mutableDate);
  mutableDate.day += (duration.weeks || 0) * 7;
  mutableDate.day += duration.days || 0;
  mutableDate.day += days;
  $735220c2d4774dd3$var$balanceDay(mutableDate);
  if (mutableDate.calendar.balanceDate) mutableDate.calendar.balanceDate(mutableDate);
  if (mutableDate.year < 1) {
    mutableDate.year = 1;
    mutableDate.month = 1;
    mutableDate.day = 1;
  }
  let maxYear = mutableDate.calendar.getYearsInEra(mutableDate);
  if (mutableDate.year > maxYear) {
    var _mutableDate_calendar_isInverseEra, _mutableDate_calendar;
    let isInverseEra = (_mutableDate_calendar_isInverseEra = (_mutableDate_calendar = mutableDate.calendar).isInverseEra) === null || _mutableDate_calendar_isInverseEra === void 0 ? void 0 : _mutableDate_calendar_isInverseEra.call(_mutableDate_calendar, mutableDate);
    mutableDate.year = maxYear;
    mutableDate.month = isInverseEra ? 1 : mutableDate.calendar.getMonthsInYear(mutableDate);
    mutableDate.day = isInverseEra ? 1 : mutableDate.calendar.getDaysInMonth(mutableDate);
  }
  if (mutableDate.month < 1) {
    mutableDate.month = 1;
    mutableDate.day = 1;
  }
  let maxMonth = mutableDate.calendar.getMonthsInYear(mutableDate);
  if (mutableDate.month > maxMonth) {
    mutableDate.month = maxMonth;
    mutableDate.day = mutableDate.calendar.getDaysInMonth(mutableDate);
  }
  mutableDate.day = Math.max(1, Math.min(mutableDate.calendar.getDaysInMonth(mutableDate), mutableDate.day));
  return mutableDate;
}
function $735220c2d4774dd3$var$addYears(date, years) {
  var _date_calendar_isInverseEra, _date_calendar;
  if ((_date_calendar_isInverseEra = (_date_calendar = date.calendar).isInverseEra) === null || _date_calendar_isInverseEra === void 0 ? void 0 : _date_calendar_isInverseEra.call(_date_calendar, date)) years = -years;
  date.year += years;
}
function $735220c2d4774dd3$var$balanceYearMonth(date) {
  while (date.month < 1) {
    $735220c2d4774dd3$var$addYears(date, -1);
    date.month += date.calendar.getMonthsInYear(date);
  }
  let monthsInYear = 0;
  while (date.month > (monthsInYear = date.calendar.getMonthsInYear(date))) {
    date.month -= monthsInYear;
    $735220c2d4774dd3$var$addYears(date, 1);
  }
}
function $735220c2d4774dd3$var$balanceDay(date) {
  while (date.day < 1) {
    date.month--;
    $735220c2d4774dd3$var$balanceYearMonth(date);
    date.day += date.calendar.getDaysInMonth(date);
  }
  while (date.day > date.calendar.getDaysInMonth(date)) {
    date.day -= date.calendar.getDaysInMonth(date);
    date.month++;
    $735220c2d4774dd3$var$balanceYearMonth(date);
  }
}
function $735220c2d4774dd3$var$constrainMonthDay(date) {
  date.month = Math.max(1, Math.min(date.calendar.getMonthsInYear(date), date.month));
  date.day = Math.max(1, Math.min(date.calendar.getDaysInMonth(date), date.day));
}
function $735220c2d4774dd3$export$c4e2ecac49351ef2(date) {
  if (date.calendar.constrainDate) date.calendar.constrainDate(date);
  date.year = Math.max(1, Math.min(date.calendar.getYearsInEra(date), date.year));
  $735220c2d4774dd3$var$constrainMonthDay(date);
}
function $735220c2d4774dd3$export$3e2544e88a25bff8(duration) {
  let inverseDuration = {};
  for (let key in duration) if (typeof duration[key] === "number") inverseDuration[key] = -duration[key];
  return inverseDuration;
}
function $735220c2d4774dd3$export$4e2d2ead65e5f7e3(date, duration) {
  return $735220c2d4774dd3$export$e16d8520af44a096(date, $735220c2d4774dd3$export$3e2544e88a25bff8(duration));
}
function $735220c2d4774dd3$export$adaa4cf7ef1b65be(date, fields) {
  let mutableDate = date.copy();
  if (fields.era != null) mutableDate.era = fields.era;
  if (fields.year != null) mutableDate.year = fields.year;
  if (fields.month != null) mutableDate.month = fields.month;
  if (fields.day != null) mutableDate.day = fields.day;
  $735220c2d4774dd3$export$c4e2ecac49351ef2(mutableDate);
  return mutableDate;
}
function $735220c2d4774dd3$export$e5d5e1c1822b6e56(value, fields) {
  let mutableValue = value.copy();
  if (fields.hour != null) mutableValue.hour = fields.hour;
  if (fields.minute != null) mutableValue.minute = fields.minute;
  if (fields.second != null) mutableValue.second = fields.second;
  if (fields.millisecond != null) mutableValue.millisecond = fields.millisecond;
  $735220c2d4774dd3$export$7555de1e070510cb(mutableValue);
  return mutableValue;
}
function $735220c2d4774dd3$var$balanceTime(time) {
  time.second += Math.floor(time.millisecond / 1e3);
  time.millisecond = $735220c2d4774dd3$var$nonNegativeMod(time.millisecond, 1e3);
  time.minute += Math.floor(time.second / 60);
  time.second = $735220c2d4774dd3$var$nonNegativeMod(time.second, 60);
  time.hour += Math.floor(time.minute / 60);
  time.minute = $735220c2d4774dd3$var$nonNegativeMod(time.minute, 60);
  let days = Math.floor(time.hour / 24);
  time.hour = $735220c2d4774dd3$var$nonNegativeMod(time.hour, 24);
  return days;
}
function $735220c2d4774dd3$export$7555de1e070510cb(time) {
  time.millisecond = Math.max(0, Math.min(time.millisecond, 1e3));
  time.second = Math.max(0, Math.min(time.second, 59));
  time.minute = Math.max(0, Math.min(time.minute, 59));
  time.hour = Math.max(0, Math.min(time.hour, 23));
}
function $735220c2d4774dd3$var$nonNegativeMod(a, b) {
  let result = a % b;
  if (result < 0) result += b;
  return result;
}
function $735220c2d4774dd3$var$addTimeFields(time, duration) {
  time.hour += duration.hours || 0;
  time.minute += duration.minutes || 0;
  time.second += duration.seconds || 0;
  time.millisecond += duration.milliseconds || 0;
  return $735220c2d4774dd3$var$balanceTime(time);
}
function $735220c2d4774dd3$export$d52ced6badfb9a4c(value, field, amount, options) {
  let mutable = value.copy();
  switch (field) {
    case "era": {
      let eras = value.calendar.getEras();
      let eraIndex = eras.indexOf(value.era);
      if (eraIndex < 0) throw new Error("Invalid era: " + value.era);
      eraIndex = $735220c2d4774dd3$var$cycleValue(eraIndex, amount, 0, eras.length - 1, options === null || options === void 0 ? void 0 : options.round);
      mutable.era = eras[eraIndex];
      $735220c2d4774dd3$export$c4e2ecac49351ef2(mutable);
      break;
    }
    case "year":
      var _mutable_calendar_isInverseEra, _mutable_calendar;
      if ((_mutable_calendar_isInverseEra = (_mutable_calendar = mutable.calendar).isInverseEra) === null || _mutable_calendar_isInverseEra === void 0 ? void 0 : _mutable_calendar_isInverseEra.call(_mutable_calendar, mutable)) amount = -amount;
      mutable.year = $735220c2d4774dd3$var$cycleValue(value.year, amount, -Infinity, 9999, options === null || options === void 0 ? void 0 : options.round);
      if (mutable.year === -Infinity) mutable.year = 1;
      if (mutable.calendar.balanceYearMonth) mutable.calendar.balanceYearMonth(mutable, value);
      break;
    case "month":
      mutable.month = $735220c2d4774dd3$var$cycleValue(value.month, amount, 1, value.calendar.getMonthsInYear(value), options === null || options === void 0 ? void 0 : options.round);
      break;
    case "day":
      mutable.day = $735220c2d4774dd3$var$cycleValue(value.day, amount, 1, value.calendar.getDaysInMonth(value), options === null || options === void 0 ? void 0 : options.round);
      break;
    default:
      throw new Error("Unsupported field " + field);
  }
  if (value.calendar.balanceDate) value.calendar.balanceDate(mutable);
  $735220c2d4774dd3$export$c4e2ecac49351ef2(mutable);
  return mutable;
}
function $735220c2d4774dd3$export$dd02b3e0007dfe28(value, field, amount, options) {
  let mutable = value.copy();
  switch (field) {
    case "hour": {
      let hours = value.hour;
      let min2 = 0;
      let max2 = 23;
      if ((options === null || options === void 0 ? void 0 : options.hourCycle) === 12) {
        let isPM = hours >= 12;
        min2 = isPM ? 12 : 0;
        max2 = isPM ? 23 : 11;
      }
      mutable.hour = $735220c2d4774dd3$var$cycleValue(hours, amount, min2, max2, options === null || options === void 0 ? void 0 : options.round);
      break;
    }
    case "minute":
      mutable.minute = $735220c2d4774dd3$var$cycleValue(value.minute, amount, 0, 59, options === null || options === void 0 ? void 0 : options.round);
      break;
    case "second":
      mutable.second = $735220c2d4774dd3$var$cycleValue(value.second, amount, 0, 59, options === null || options === void 0 ? void 0 : options.round);
      break;
    case "millisecond":
      mutable.millisecond = $735220c2d4774dd3$var$cycleValue(value.millisecond, amount, 0, 999, options === null || options === void 0 ? void 0 : options.round);
      break;
    default:
      throw new Error("Unsupported field " + field);
  }
  return mutable;
}
function $735220c2d4774dd3$var$cycleValue(value, amount, min2, max2, round2 = false) {
  if (round2) {
    value += Math.sign(amount);
    if (value < min2) value = max2;
    let div = Math.abs(amount);
    if (amount > 0) value = Math.ceil(value / div) * div;
    else value = Math.floor(value / div) * div;
    if (value > max2) value = min2;
  } else {
    value += amount;
    if (value < min2) value = max2 - (min2 - value - 1);
    else if (value > max2) value = min2 + (value - max2 - 1);
  }
  return value;
}
function $735220c2d4774dd3$export$96b1d28349274637(dateTime, duration) {
  let ms;
  if (duration.years != null && duration.years !== 0 || duration.months != null && duration.months !== 0 || duration.weeks != null && duration.weeks !== 0 || duration.days != null && duration.days !== 0) {
    let res2 = $735220c2d4774dd3$export$e16d8520af44a096((0, $11d87f3f76e88657$export$b21e0b124e224484)(dateTime), {
      years: duration.years,
      months: duration.months,
      weeks: duration.weeks,
      days: duration.days
    });
    ms = (0, $11d87f3f76e88657$export$5107c82f94518f5c)(res2, dateTime.timeZone);
  } else
    ms = (0, $11d87f3f76e88657$export$bd4fb2bc8bb06fb)(dateTime) - dateTime.offset;
  ms += duration.milliseconds || 0;
  ms += (duration.seconds || 0) * 1e3;
  ms += (duration.minutes || 0) * 6e4;
  ms += (duration.hours || 0) * 36e5;
  let res = (0, $11d87f3f76e88657$export$1b96692a1ba042ac)(ms, dateTime.timeZone);
  return (0, $11d87f3f76e88657$export$b4a036af3fc0b032)(res, dateTime.calendar);
}
function $735220c2d4774dd3$export$6814caac34ca03c7(dateTime, duration) {
  return $735220c2d4774dd3$export$96b1d28349274637(dateTime, $735220c2d4774dd3$export$3e2544e88a25bff8(duration));
}
function $735220c2d4774dd3$export$9a297d111fc86b79(dateTime, field, amount, options) {
  switch (field) {
    case "hour": {
      let min2 = 0;
      let max2 = 23;
      if ((options === null || options === void 0 ? void 0 : options.hourCycle) === 12) {
        let isPM = dateTime.hour >= 12;
        min2 = isPM ? 12 : 0;
        max2 = isPM ? 23 : 11;
      }
      let plainDateTime = (0, $11d87f3f76e88657$export$b21e0b124e224484)(dateTime);
      let minDate = (0, $11d87f3f76e88657$export$b4a036af3fc0b032)($735220c2d4774dd3$export$e5d5e1c1822b6e56(plainDateTime, {
        hour: min2
      }), new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
      let minAbsolute = [
        (0, $11d87f3f76e88657$export$5107c82f94518f5c)(minDate, dateTime.timeZone, "earlier"),
        (0, $11d87f3f76e88657$export$5107c82f94518f5c)(minDate, dateTime.timeZone, "later")
      ].filter((ms2) => (0, $11d87f3f76e88657$export$1b96692a1ba042ac)(ms2, dateTime.timeZone).day === minDate.day)[0];
      let maxDate = (0, $11d87f3f76e88657$export$b4a036af3fc0b032)($735220c2d4774dd3$export$e5d5e1c1822b6e56(plainDateTime, {
        hour: max2
      }), new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
      let maxAbsolute = [
        (0, $11d87f3f76e88657$export$5107c82f94518f5c)(maxDate, dateTime.timeZone, "earlier"),
        (0, $11d87f3f76e88657$export$5107c82f94518f5c)(maxDate, dateTime.timeZone, "later")
      ].filter((ms2) => (0, $11d87f3f76e88657$export$1b96692a1ba042ac)(ms2, dateTime.timeZone).day === maxDate.day).pop();
      let ms = (0, $11d87f3f76e88657$export$bd4fb2bc8bb06fb)(dateTime) - dateTime.offset;
      let hours = Math.floor(ms / $735220c2d4774dd3$var$ONE_HOUR);
      let remainder = ms % $735220c2d4774dd3$var$ONE_HOUR;
      ms = $735220c2d4774dd3$var$cycleValue(hours, amount, Math.floor(minAbsolute / $735220c2d4774dd3$var$ONE_HOUR), Math.floor(maxAbsolute / $735220c2d4774dd3$var$ONE_HOUR), options === null || options === void 0 ? void 0 : options.round) * $735220c2d4774dd3$var$ONE_HOUR + remainder;
      return (0, $11d87f3f76e88657$export$b4a036af3fc0b032)((0, $11d87f3f76e88657$export$1b96692a1ba042ac)(ms, dateTime.timeZone), dateTime.calendar);
    }
    case "minute":
    case "second":
    case "millisecond":
      return $735220c2d4774dd3$export$dd02b3e0007dfe28(dateTime, field, amount, options);
    case "era":
    case "year":
    case "month":
    case "day": {
      let res = $735220c2d4774dd3$export$d52ced6badfb9a4c((0, $11d87f3f76e88657$export$b21e0b124e224484)(dateTime), field, amount, options);
      let ms = (0, $11d87f3f76e88657$export$5107c82f94518f5c)(res, dateTime.timeZone);
      return (0, $11d87f3f76e88657$export$b4a036af3fc0b032)((0, $11d87f3f76e88657$export$1b96692a1ba042ac)(ms, dateTime.timeZone), dateTime.calendar);
    }
    default:
      throw new Error("Unsupported field " + field);
  }
}
function $735220c2d4774dd3$export$31b5430eb18be4f8(dateTime, fields, disambiguation) {
  let plainDateTime = (0, $11d87f3f76e88657$export$b21e0b124e224484)(dateTime);
  let res = $735220c2d4774dd3$export$e5d5e1c1822b6e56($735220c2d4774dd3$export$adaa4cf7ef1b65be(plainDateTime, fields), fields);
  if (res.compare(plainDateTime) === 0) return dateTime;
  let ms = (0, $11d87f3f76e88657$export$5107c82f94518f5c)(res, dateTime.timeZone, disambiguation);
  return (0, $11d87f3f76e88657$export$b4a036af3fc0b032)((0, $11d87f3f76e88657$export$1b96692a1ba042ac)(ms, dateTime.timeZone), dateTime.calendar);
}
var $fae977aafc393c5c$var$DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
var $fae977aafc393c5c$var$DATE_TIME_RE = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?$/;
var $fae977aafc393c5c$var$ZONED_DATE_TIME_RE = /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}))?(?::(\d{2}))?(?::(\d{2}))?(\.\d+)?(?:([+-]\d{2})(?::?(\d{2}))?)?\[(.*?)\]$/;
var $fae977aafc393c5c$var$requiredDurationTimeGroups = [
  "hours",
  "minutes",
  "seconds"
];
var $fae977aafc393c5c$var$requiredDurationGroups = [
  "years",
  "months",
  "weeks",
  "days",
  ...$fae977aafc393c5c$var$requiredDurationTimeGroups
];
function $fae977aafc393c5c$export$6b862160d295c8e(value) {
  let m = value.match($fae977aafc393c5c$var$DATE_RE);
  if (!m) throw new Error("Invalid ISO 8601 date string: " + value);
  let date = new (0, $35ea8db9cb2ccb90$export$99faa760c7908e4f)($fae977aafc393c5c$var$parseNumber(m[1], 0, 9999), $fae977aafc393c5c$var$parseNumber(m[2], 1, 12), 1);
  date.day = $fae977aafc393c5c$var$parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
  return date;
}
function $fae977aafc393c5c$export$588937bcd60ade55(value) {
  let m = value.match($fae977aafc393c5c$var$DATE_TIME_RE);
  if (!m) throw new Error("Invalid ISO 8601 date time string: " + value);
  let date = new (0, $35ea8db9cb2ccb90$export$ca871e8dbb80966f)($fae977aafc393c5c$var$parseNumber(m[1], 1, 9999), $fae977aafc393c5c$var$parseNumber(m[2], 1, 12), 1, m[4] ? $fae977aafc393c5c$var$parseNumber(m[4], 0, 23) : 0, m[5] ? $fae977aafc393c5c$var$parseNumber(m[5], 0, 59) : 0, m[6] ? $fae977aafc393c5c$var$parseNumber(m[6], 0, 59) : 0, m[7] ? $fae977aafc393c5c$var$parseNumber(m[7], 0, Infinity) * 1e3 : 0);
  date.day = $fae977aafc393c5c$var$parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
  return date;
}
function $fae977aafc393c5c$export$fd7893f06e92a6a4(value, disambiguation) {
  let m = value.match($fae977aafc393c5c$var$ZONED_DATE_TIME_RE);
  if (!m) throw new Error("Invalid ISO 8601 date time string: " + value);
  let date = new (0, $35ea8db9cb2ccb90$export$d3b7288e7994edea)($fae977aafc393c5c$var$parseNumber(m[1], 1, 9999), $fae977aafc393c5c$var$parseNumber(m[2], 1, 12), 1, m[10], 0, m[4] ? $fae977aafc393c5c$var$parseNumber(m[4], 0, 23) : 0, m[5] ? $fae977aafc393c5c$var$parseNumber(m[5], 0, 59) : 0, m[6] ? $fae977aafc393c5c$var$parseNumber(m[6], 0, 59) : 0, m[7] ? $fae977aafc393c5c$var$parseNumber(m[7], 0, Infinity) * 1e3 : 0);
  date.day = $fae977aafc393c5c$var$parseNumber(m[3], 0, date.calendar.getDaysInMonth(date));
  let plainDateTime = (0, $11d87f3f76e88657$export$b21e0b124e224484)(date);
  let ms;
  if (m[8]) {
    var _m_;
    date.offset = $fae977aafc393c5c$var$parseNumber(m[8], -23, 23) * 36e5 + $fae977aafc393c5c$var$parseNumber((_m_ = m[9]) !== null && _m_ !== void 0 ? _m_ : "0", 0, 59) * 6e4;
    ms = (0, $11d87f3f76e88657$export$bd4fb2bc8bb06fb)(date) - date.offset;
    let absolutes = (0, $11d87f3f76e88657$export$136f38efe7caf549)(plainDateTime, date.timeZone);
    if (!absolutes.includes(ms)) throw new Error(`Offset ${$fae977aafc393c5c$var$offsetToString(date.offset)} is invalid for ${$fae977aafc393c5c$export$4223de14708adc63(date)} in ${date.timeZone}`);
  } else
    ms = (0, $11d87f3f76e88657$export$5107c82f94518f5c)((0, $11d87f3f76e88657$export$b21e0b124e224484)(plainDateTime), date.timeZone, disambiguation);
  return (0, $11d87f3f76e88657$export$1b96692a1ba042ac)(ms, date.timeZone);
}
function $fae977aafc393c5c$var$parseNumber(value, min2, max2) {
  let val = Number(value);
  if (val < min2 || val > max2) throw new RangeError(`Value out of range: ${min2} <= ${val} <= ${max2}`);
  return val;
}
function $fae977aafc393c5c$export$f59dee82248f5ad4(time) {
  return `${String(time.hour).padStart(2, "0")}:${String(time.minute).padStart(2, "0")}:${String(time.second).padStart(2, "0")}${time.millisecond ? String(time.millisecond / 1e3).slice(1) : ""}`;
}
function $fae977aafc393c5c$export$60dfd74aa96791bd(date) {
  let gregorianDate = (0, $11d87f3f76e88657$export$b4a036af3fc0b032)(date, new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)());
  return `${String(gregorianDate.year).padStart(4, "0")}-${String(gregorianDate.month).padStart(2, "0")}-${String(gregorianDate.day).padStart(2, "0")}`;
}
function $fae977aafc393c5c$export$4223de14708adc63(date) {
  return `${$fae977aafc393c5c$export$60dfd74aa96791bd(date)}T${$fae977aafc393c5c$export$f59dee82248f5ad4(date)}`;
}
function $fae977aafc393c5c$var$offsetToString(offset2) {
  let sign = Math.sign(offset2) < 0 ? "-" : "+";
  offset2 = Math.abs(offset2);
  let offsetHours = Math.floor(offset2 / 36e5);
  let offsetMinutes = offset2 % 36e5 / 6e4;
  return `${sign}${String(offsetHours).padStart(2, "0")}:${String(offsetMinutes).padStart(2, "0")}`;
}
function $fae977aafc393c5c$export$bf79f1ebf4b18792(date) {
  return `${$fae977aafc393c5c$export$4223de14708adc63(date)}${$fae977aafc393c5c$var$offsetToString(date.offset)}[${date.timeZone}]`;
}
function $35ea8db9cb2ccb90$var$shiftArgs(args) {
  let calendar = typeof args[0] === "object" ? args.shift() : new (0, $3b62074eb05584b2$export$80ee6245ec4f29ec)();
  let era;
  if (typeof args[0] === "string") era = args.shift();
  else {
    let eras = calendar.getEras();
    era = eras[eras.length - 1];
  }
  let year = args.shift();
  let month = args.shift();
  let day = args.shift();
  return [
    calendar,
    era,
    year,
    month,
    day
  ];
}
var $35ea8db9cb2ccb90$var$_type = /* @__PURE__ */ new WeakMap();
var $35ea8db9cb2ccb90$export$99faa760c7908e4f = class _$35ea8db9cb2ccb90$export$99faa760c7908e4f {
  /** Returns a copy of this date. */
  copy() {
    if (this.era) return new _$35ea8db9cb2ccb90$export$99faa760c7908e4f(this.calendar, this.era, this.year, this.month, this.day);
    else return new _$35ea8db9cb2ccb90$export$99faa760c7908e4f(this.calendar, this.year, this.month, this.day);
  }
  /** Returns a new `CalendarDate` with the given duration added to it. */
  add(duration) {
    return (0, $735220c2d4774dd3$export$e16d8520af44a096)(this, duration);
  }
  /** Returns a new `CalendarDate` with the given duration subtracted from it. */
  subtract(duration) {
    return (0, $735220c2d4774dd3$export$4e2d2ead65e5f7e3)(this, duration);
  }
  /** Returns a new `CalendarDate` with the given fields set to the provided values. Other fields will be constrained accordingly. */
  set(fields) {
    return (0, $735220c2d4774dd3$export$adaa4cf7ef1b65be)(this, fields);
  }
  /**
  * Returns a new `CalendarDate` with the given field adjusted by a specified amount.
  * When the resulting value reaches the limits of the field, it wraps around.
  */
  cycle(field, amount, options) {
    return (0, $735220c2d4774dd3$export$d52ced6badfb9a4c)(this, field, amount, options);
  }
  /** Converts the date to a native JavaScript Date object, with the time set to midnight in the given time zone. */
  toDate(timeZone) {
    return (0, $11d87f3f76e88657$export$e67a095c620b86fe)(this, timeZone);
  }
  /** Converts the date to an ISO 8601 formatted string. */
  toString() {
    return (0, $fae977aafc393c5c$export$60dfd74aa96791bd)(this);
  }
  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
  compare(b) {
    return (0, $14e0f24ef4ac5c92$export$68781ddf31c0090f)(this, b);
  }
  constructor(...args) {
    (0, _class_private_field_init)(this, $35ea8db9cb2ccb90$var$_type, {
      writable: true,
      value: void 0
    });
    let [calendar, era, year, month, day] = $35ea8db9cb2ccb90$var$shiftArgs(args);
    this.calendar = calendar;
    this.era = era;
    this.year = year;
    this.month = month;
    this.day = day;
    (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(this);
  }
};
var $35ea8db9cb2ccb90$var$_type2 = /* @__PURE__ */ new WeakMap();
var $35ea8db9cb2ccb90$export$ca871e8dbb80966f = class _$35ea8db9cb2ccb90$export$ca871e8dbb80966f {
  /** Returns a copy of this date. */
  copy() {
    if (this.era) return new _$35ea8db9cb2ccb90$export$ca871e8dbb80966f(this.calendar, this.era, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
    else return new _$35ea8db9cb2ccb90$export$ca871e8dbb80966f(this.calendar, this.year, this.month, this.day, this.hour, this.minute, this.second, this.millisecond);
  }
  /** Returns a new `CalendarDateTime` with the given duration added to it. */
  add(duration) {
    return (0, $735220c2d4774dd3$export$e16d8520af44a096)(this, duration);
  }
  /** Returns a new `CalendarDateTime` with the given duration subtracted from it. */
  subtract(duration) {
    return (0, $735220c2d4774dd3$export$4e2d2ead65e5f7e3)(this, duration);
  }
  /** Returns a new `CalendarDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
  set(fields) {
    return (0, $735220c2d4774dd3$export$adaa4cf7ef1b65be)((0, $735220c2d4774dd3$export$e5d5e1c1822b6e56)(this, fields), fields);
  }
  /**
  * Returns a new `CalendarDateTime` with the given field adjusted by a specified amount.
  * When the resulting value reaches the limits of the field, it wraps around.
  */
  cycle(field, amount, options) {
    switch (field) {
      case "era":
      case "year":
      case "month":
      case "day":
        return (0, $735220c2d4774dd3$export$d52ced6badfb9a4c)(this, field, amount, options);
      default:
        return (0, $735220c2d4774dd3$export$dd02b3e0007dfe28)(this, field, amount, options);
    }
  }
  /** Converts the date to a native JavaScript Date object in the given time zone. */
  toDate(timeZone, disambiguation) {
    return (0, $11d87f3f76e88657$export$e67a095c620b86fe)(this, timeZone, disambiguation);
  }
  /** Converts the date to an ISO 8601 formatted string. */
  toString() {
    return (0, $fae977aafc393c5c$export$4223de14708adc63)(this);
  }
  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
  compare(b) {
    let res = (0, $14e0f24ef4ac5c92$export$68781ddf31c0090f)(this, b);
    if (res === 0) return (0, $14e0f24ef4ac5c92$export$c19a80a9721b80f6)(this, (0, $11d87f3f76e88657$export$b21e0b124e224484)(b));
    return res;
  }
  constructor(...args) {
    (0, _class_private_field_init)(this, $35ea8db9cb2ccb90$var$_type2, {
      writable: true,
      value: void 0
    });
    let [calendar, era, year, month, day] = $35ea8db9cb2ccb90$var$shiftArgs(args);
    this.calendar = calendar;
    this.era = era;
    this.year = year;
    this.month = month;
    this.day = day;
    this.hour = args.shift() || 0;
    this.minute = args.shift() || 0;
    this.second = args.shift() || 0;
    this.millisecond = args.shift() || 0;
    (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(this);
  }
};
var $35ea8db9cb2ccb90$var$_type3 = /* @__PURE__ */ new WeakMap();
var $35ea8db9cb2ccb90$export$d3b7288e7994edea = class _$35ea8db9cb2ccb90$export$d3b7288e7994edea {
  /** Returns a copy of this date. */
  copy() {
    if (this.era) return new _$35ea8db9cb2ccb90$export$d3b7288e7994edea(this.calendar, this.era, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
    else return new _$35ea8db9cb2ccb90$export$d3b7288e7994edea(this.calendar, this.year, this.month, this.day, this.timeZone, this.offset, this.hour, this.minute, this.second, this.millisecond);
  }
  /** Returns a new `ZonedDateTime` with the given duration added to it. */
  add(duration) {
    return (0, $735220c2d4774dd3$export$96b1d28349274637)(this, duration);
  }
  /** Returns a new `ZonedDateTime` with the given duration subtracted from it. */
  subtract(duration) {
    return (0, $735220c2d4774dd3$export$6814caac34ca03c7)(this, duration);
  }
  /** Returns a new `ZonedDateTime` with the given fields set to the provided values. Other fields will be constrained accordingly. */
  set(fields, disambiguation) {
    return (0, $735220c2d4774dd3$export$31b5430eb18be4f8)(this, fields, disambiguation);
  }
  /**
  * Returns a new `ZonedDateTime` with the given field adjusted by a specified amount.
  * When the resulting value reaches the limits of the field, it wraps around.
  */
  cycle(field, amount, options) {
    return (0, $735220c2d4774dd3$export$9a297d111fc86b79)(this, field, amount, options);
  }
  /** Converts the date to a native JavaScript Date object. */
  toDate() {
    return (0, $11d87f3f76e88657$export$83aac07b4c37b25)(this);
  }
  /** Converts the date to an ISO 8601 formatted string, including the UTC offset and time zone identifier. */
  toString() {
    return (0, $fae977aafc393c5c$export$bf79f1ebf4b18792)(this);
  }
  /** Converts the date to an ISO 8601 formatted string in UTC. */
  toAbsoluteString() {
    return this.toDate().toISOString();
  }
  /** Compares this date with another. A negative result indicates that this date is before the given one, and a positive date indicates that it is after. */
  compare(b) {
    return this.toDate().getTime() - (0, $11d87f3f76e88657$export$84c95a83c799e074)(b, this.timeZone).toDate().getTime();
  }
  constructor(...args) {
    (0, _class_private_field_init)(this, $35ea8db9cb2ccb90$var$_type3, {
      writable: true,
      value: void 0
    });
    let [calendar, era, year, month, day] = $35ea8db9cb2ccb90$var$shiftArgs(args);
    let timeZone = args.shift();
    let offset2 = args.shift();
    this.calendar = calendar;
    this.era = era;
    this.year = year;
    this.month = month;
    this.day = day;
    this.timeZone = timeZone;
    this.offset = offset2;
    this.hour = args.shift() || 0;
    this.minute = args.shift() || 0;
    this.second = args.shift() || 0;
    this.millisecond = args.shift() || 0;
    (0, $735220c2d4774dd3$export$c4e2ecac49351ef2)(this);
  }
};
var $7c5f6fbf42389787$var$HOUR_PARTS = 1080;
var $7c5f6fbf42389787$var$DAY_PARTS = 24 * $7c5f6fbf42389787$var$HOUR_PARTS;
var $7c5f6fbf42389787$var$MONTH_DAYS = 29;
var $7c5f6fbf42389787$var$MONTH_FRACT = 12 * $7c5f6fbf42389787$var$HOUR_PARTS + 793;
var $7c5f6fbf42389787$var$MONTH_PARTS = $7c5f6fbf42389787$var$MONTH_DAYS * $7c5f6fbf42389787$var$DAY_PARTS + $7c5f6fbf42389787$var$MONTH_FRACT;
var $fb18d541ea1ad717$var$formatterCache = /* @__PURE__ */ new Map();
var $fb18d541ea1ad717$export$ad991b66133851cf = class {
  /** Formats a date as a string according to the locale and format options passed to the constructor. */
  format(value) {
    return this.formatter.format(value);
  }
  /** Formats a date to an array of parts such as separators, numbers, punctuation, and more. */
  formatToParts(value) {
    return this.formatter.formatToParts(value);
  }
  /** Formats a date range as a string. */
  formatRange(start, end) {
    if (typeof this.formatter.formatRange === "function")
      return this.formatter.formatRange(start, end);
    if (end < start) throw new RangeError("End date must be >= start date");
    return `${this.formatter.format(start)} – ${this.formatter.format(end)}`;
  }
  /** Formats a date range as an array of parts. */
  formatRangeToParts(start, end) {
    if (typeof this.formatter.formatRangeToParts === "function")
      return this.formatter.formatRangeToParts(start, end);
    if (end < start) throw new RangeError("End date must be >= start date");
    let startParts = this.formatter.formatToParts(start);
    let endParts = this.formatter.formatToParts(end);
    return [
      ...startParts.map((p) => ({
        ...p,
        source: "startRange"
      })),
      {
        type: "literal",
        value: " – ",
        source: "shared"
      },
      ...endParts.map((p) => ({
        ...p,
        source: "endRange"
      }))
    ];
  }
  /** Returns the resolved formatting options based on the values passed to the constructor. */
  resolvedOptions() {
    let resolvedOptions = this.formatter.resolvedOptions();
    if ($fb18d541ea1ad717$var$hasBuggyResolvedHourCycle()) {
      if (!this.resolvedHourCycle) this.resolvedHourCycle = $fb18d541ea1ad717$var$getResolvedHourCycle(resolvedOptions.locale, this.options);
      resolvedOptions.hourCycle = this.resolvedHourCycle;
      resolvedOptions.hour12 = this.resolvedHourCycle === "h11" || this.resolvedHourCycle === "h12";
    }
    if (resolvedOptions.calendar === "ethiopic-amete-alem") resolvedOptions.calendar = "ethioaa";
    return resolvedOptions;
  }
  constructor(locale, options = {}) {
    this.formatter = $fb18d541ea1ad717$var$getCachedDateFormatter(locale, options);
    this.options = options;
  }
};
var $fb18d541ea1ad717$var$hour12Preferences = {
  true: {
    // Only Japanese uses the h11 style for 12 hour time. All others use h12.
    ja: "h11"
  },
  false: {}
};
function $fb18d541ea1ad717$var$getCachedDateFormatter(locale, options = {}) {
  if (typeof options.hour12 === "boolean" && $fb18d541ea1ad717$var$hasBuggyHour12Behavior()) {
    options = {
      ...options
    };
    let pref = $fb18d541ea1ad717$var$hour12Preferences[String(options.hour12)][locale.split("-")[0]];
    let defaultHourCycle = options.hour12 ? "h12" : "h23";
    options.hourCycle = pref !== null && pref !== void 0 ? pref : defaultHourCycle;
    delete options.hour12;
  }
  let cacheKey = locale + (options ? Object.entries(options).sort((a, b) => a[0] < b[0] ? -1 : 1).join() : "");
  if ($fb18d541ea1ad717$var$formatterCache.has(cacheKey)) return $fb18d541ea1ad717$var$formatterCache.get(cacheKey);
  let numberFormatter = new Intl.DateTimeFormat(locale, options);
  $fb18d541ea1ad717$var$formatterCache.set(cacheKey, numberFormatter);
  return numberFormatter;
}
var $fb18d541ea1ad717$var$_hasBuggyHour12Behavior = null;
function $fb18d541ea1ad717$var$hasBuggyHour12Behavior() {
  if ($fb18d541ea1ad717$var$_hasBuggyHour12Behavior == null) $fb18d541ea1ad717$var$_hasBuggyHour12Behavior = new Intl.DateTimeFormat("en-US", {
    hour: "numeric",
    hour12: false
  }).format(new Date(2020, 2, 3, 0)) === "24";
  return $fb18d541ea1ad717$var$_hasBuggyHour12Behavior;
}
var $fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle = null;
function $fb18d541ea1ad717$var$hasBuggyResolvedHourCycle() {
  if ($fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle == null) $fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle = new Intl.DateTimeFormat("fr", {
    hour: "numeric",
    hour12: false
  }).resolvedOptions().hourCycle === "h12";
  return $fb18d541ea1ad717$var$_hasBuggyResolvedHourCycle;
}
function $fb18d541ea1ad717$var$getResolvedHourCycle(locale, options) {
  if (!options.timeStyle && !options.hour) return void 0;
  locale = locale.replace(/(-u-)?-nu-[a-zA-Z0-9]+/, "");
  locale += (locale.includes("-u-") ? "" : "-u") + "-nu-latn";
  let formatter = $fb18d541ea1ad717$var$getCachedDateFormatter(locale, {
    ...options,
    timeZone: void 0
    // use local timezone
  });
  let min2 = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 0)).find((p) => p.type === "hour").value, 10);
  let max2 = parseInt(formatter.formatToParts(new Date(2020, 2, 3, 23)).find((p) => p.type === "hour").value, 10);
  if (min2 === 0 && max2 === 23) return "h23";
  if (min2 === 24 && max2 === 23) return "h24";
  if (min2 === 0 && max2 === 11) return "h11";
  if (min2 === 12 && max2 === 11) return "h12";
  throw new Error("Unexpected hour cycle result");
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/utils.js
var defaultDateDefaults = {
  defaultValue: void 0,
  defaultPlaceholder: void 0,
  granularity: "day"
};
function getDefaultDate(props) {
  const withDefaults = { ...defaultDateDefaults, ...props };
  const { defaultValue, defaultPlaceholder, granularity } = withDefaults;
  if (Array.isArray(defaultValue) && defaultValue.length) {
    return defaultValue[defaultValue.length - 1];
  }
  if (defaultValue && !Array.isArray(defaultValue)) {
    return defaultValue;
  } else if (defaultPlaceholder) {
    return defaultPlaceholder;
  } else {
    const date = /* @__PURE__ */ new Date();
    const year = date.getFullYear();
    const month = date.getMonth() + 1;
    const day = date.getDate();
    const calendarDateTimeGranularities = ["hour", "minute", "second"];
    if (calendarDateTimeGranularities.includes(granularity ?? "day")) {
      return new $35ea8db9cb2ccb90$export$ca871e8dbb80966f(year, month, day, 0, 0, 0);
    }
    return new $35ea8db9cb2ccb90$export$99faa760c7908e4f(year, month, day);
  }
}
function parseStringToDateValue(dateStr, referenceVal) {
  let dateValue;
  if (referenceVal instanceof $35ea8db9cb2ccb90$export$d3b7288e7994edea) {
    dateValue = $fae977aafc393c5c$export$fd7893f06e92a6a4(dateStr);
  } else if (referenceVal instanceof $35ea8db9cb2ccb90$export$ca871e8dbb80966f) {
    dateValue = $fae977aafc393c5c$export$588937bcd60ade55(dateStr);
  } else {
    dateValue = $fae977aafc393c5c$export$6b862160d295c8e(dateStr);
  }
  return dateValue.calendar !== referenceVal.calendar ? $11d87f3f76e88657$export$b4a036af3fc0b032(dateValue, referenceVal.calendar) : dateValue;
}
function toDate(dateValue, tz = $14e0f24ef4ac5c92$export$aa8b41735afcabd2()) {
  if (dateValue instanceof $35ea8db9cb2ccb90$export$d3b7288e7994edea) {
    return dateValue.toDate();
  } else {
    return dateValue.toDate(tz);
  }
}
function isCalendarDateTime(dateValue) {
  return dateValue instanceof $35ea8db9cb2ccb90$export$ca871e8dbb80966f;
}
function isZonedDateTime(dateValue) {
  return dateValue instanceof $35ea8db9cb2ccb90$export$d3b7288e7994edea;
}
function hasTime(dateValue) {
  return isCalendarDateTime(dateValue) || isZonedDateTime(dateValue);
}
function getDaysInMonth(date) {
  if (date instanceof Date) {
    const year = date.getFullYear();
    const month = date.getMonth() + 1;
    return new Date(year, month, 0).getDate();
  } else {
    return date.set({ day: 100 }).day;
  }
}
function isBefore(dateToCompare, referenceDate) {
  return dateToCompare.compare(referenceDate) < 0;
}
function isAfter(dateToCompare, referenceDate) {
  return dateToCompare.compare(referenceDate) > 0;
}
function isBeforeOrSame(dateToCompare, referenceDate) {
  return dateToCompare.compare(referenceDate) <= 0;
}
function isAfterOrSame(dateToCompare, referenceDate) {
  return dateToCompare.compare(referenceDate) >= 0;
}
function isBetweenInclusive(date, start, end) {
  return isAfterOrSame(date, start) && isBeforeOrSame(date, end);
}
function getLastFirstDayOfWeek(date, firstDayOfWeek, locale) {
  const day = $14e0f24ef4ac5c92$export$2061056d06d7cdf7(date, locale);
  if (firstDayOfWeek > day) {
    return date.subtract({ days: day + 7 - firstDayOfWeek });
  }
  if (firstDayOfWeek === day) {
    return date;
  }
  return date.subtract({ days: day - firstDayOfWeek });
}
function getNextLastDayOfWeek(date, firstDayOfWeek, locale) {
  const day = $14e0f24ef4ac5c92$export$2061056d06d7cdf7(date, locale);
  const lastDayOfWeek = firstDayOfWeek === 0 ? 6 : firstDayOfWeek - 1;
  if (day === lastDayOfWeek) {
    return date;
  }
  if (day > lastDayOfWeek) {
    return date.add({ days: 7 - day + lastDayOfWeek });
  }
  return date.add({ days: lastDayOfWeek - day });
}
function areAllDaysBetweenValid(start, end, isUnavailable, isDisabled) {
  if (isUnavailable === void 0 && isDisabled === void 0) {
    return true;
  }
  let dCurrent = start.add({ days: 1 });
  if ((isDisabled == null ? void 0 : isDisabled(dCurrent)) || (isUnavailable == null ? void 0 : isUnavailable(dCurrent))) {
    return false;
  }
  const dEnd = end;
  while (dCurrent.compare(dEnd) < 0) {
    dCurrent = dCurrent.add({ days: 1 });
    if ((isDisabled == null ? void 0 : isDisabled(dCurrent)) || (isUnavailable == null ? void 0 : isUnavailable(dCurrent))) {
      return false;
    }
  }
  return true;
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/formatter.js
function createFormatter(initialLocale) {
  let locale = initialLocale;
  function setLocale(newLocale) {
    locale = newLocale;
  }
  function getLocale() {
    return locale;
  }
  function custom(date, options) {
    return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, options).format(date);
  }
  function selectedDate(date, includeTime = true) {
    if (hasTime(date) && includeTime) {
      return custom(toDate(date), {
        dateStyle: "long",
        timeStyle: "long"
      });
    } else {
      return custom(toDate(date), {
        dateStyle: "long"
      });
    }
  }
  function fullMonthAndYear(date) {
    return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, { month: "long", year: "numeric" }).format(date);
  }
  function fullMonth(date) {
    return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, { month: "long" }).format(date);
  }
  function fullYear(date) {
    return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, { year: "numeric" }).format(date);
  }
  function toParts(date, options) {
    if (isZonedDateTime(date)) {
      return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, {
        ...options,
        timeZone: date.timeZone
      }).formatToParts(toDate(date));
    } else {
      return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, options).formatToParts(toDate(date));
    }
  }
  function dayOfWeek(date, length = "narrow") {
    return new $fb18d541ea1ad717$export$ad991b66133851cf(locale, { weekday: length }).format(date);
  }
  function dayPeriod(date) {
    var _a;
    const parts = new $fb18d541ea1ad717$export$ad991b66133851cf(locale, {
      hour: "numeric",
      minute: "numeric"
    }).formatToParts(date);
    const value = (_a = parts.find((p) => p.type === "dayPeriod")) == null ? void 0 : _a.value;
    if (value === "PM") {
      return "PM";
    }
    return "AM";
  }
  const defaultPartOptions = {
    year: "numeric",
    month: "numeric",
    day: "numeric",
    hour: "numeric",
    minute: "numeric",
    second: "numeric"
  };
  function part(dateObj, type, options = {}) {
    const opts = { ...defaultPartOptions, ...options };
    const parts = toParts(dateObj, opts);
    const part2 = parts.find((p) => p.type === type);
    return part2 ? part2.value : "";
  }
  return {
    setLocale,
    getLocale,
    fullMonth,
    fullYear,
    fullMonthAndYear,
    toParts,
    custom,
    part,
    dayPeriod,
    selectedDate,
    dayOfWeek
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/store.js
function dateStore(store, defaultValue) {
  const { set, update, subscribe: subscribe2, get } = withGet(store);
  function add(duration) {
    update((d) => {
      return d.add(duration);
    });
  }
  function nextPage(amount) {
    update((d) => {
      return d.set({ day: 1 }).add({ months: amount });
    });
  }
  function prevPage(amount) {
    update((d) => {
      return d.set({ day: 1 }).subtract({ months: amount });
    });
  }
  function subtract(duration) {
    update((d) => {
      return d.subtract(duration);
    });
  }
  function setDate(fields, disambiguation) {
    if (disambiguation) {
      update((d) => {
        return d.set(fields, disambiguation);
      });
      return;
    }
    update((d) => {
      return d.set(fields);
    });
  }
  function reset() {
    update(() => {
      return defaultValue;
    });
  }
  function toWritable() {
    return {
      set,
      subscribe: subscribe2,
      update,
      get
    };
  }
  return {
    get,
    set,
    update,
    subscribe: subscribe2,
    add,
    subtract,
    setDate,
    reset,
    toWritable,
    nextPage,
    prevPage
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/placeholders.js
var supportedLocales = [
  "ach",
  "af",
  "am",
  "an",
  "ar",
  "ast",
  "az",
  "be",
  "bg",
  "bn",
  "br",
  "bs",
  "ca",
  "cak",
  "ckb",
  "cs",
  "cy",
  "da",
  "de",
  "dsb",
  "el",
  "en",
  "eo",
  "es",
  "et",
  "eu",
  "fa",
  "ff",
  "fi",
  "fr",
  "fy",
  "ga",
  "gd",
  "gl",
  "he",
  "hr",
  "hsb",
  "hu",
  "ia",
  "id",
  "it",
  "ja",
  "ka",
  "kk",
  "kn",
  "ko",
  "lb",
  "lo",
  "lt",
  "lv",
  "meh",
  "ml",
  "ms",
  "nl",
  "nn",
  "no",
  "oc",
  "pl",
  "pt",
  "rm",
  "ro",
  "ru",
  "sc",
  "scn",
  "sk",
  "sl",
  "sr",
  "sv",
  "szl",
  "tg",
  "th",
  "tr",
  "uk",
  "zh-CN",
  "zh-TW"
];
var placeholderFields = ["year", "month", "day"];
var placeholders = {
  ach: { year: "mwaka", month: "dwe", day: "nino" },
  af: { year: "jjjj", month: "mm", day: "dd" },
  am: { year: "ዓዓዓዓ", month: "ሚሜ", day: "ቀቀ" },
  an: { year: "aaaa", month: "mm", day: "dd" },
  ar: { year: "سنة", month: "شهر", day: "يوم" },
  ast: { year: "aaaa", month: "mm", day: "dd" },
  az: { year: "iiii", month: "aa", day: "gg" },
  be: { year: "гггг", month: "мм", day: "дд" },
  bg: { year: "гггг", month: "мм", day: "дд" },
  bn: { year: "yyyy", month: "মিমি", day: "dd" },
  br: { year: "bbbb", month: "mm", day: "dd" },
  bs: { year: "gggg", month: "mm", day: "dd" },
  ca: { year: "aaaa", month: "mm", day: "dd" },
  cak: { year: "jjjj", month: "ii", day: "q'q'" },
  ckb: { year: "ساڵ", month: "مانگ", day: "ڕۆژ" },
  cs: { year: "rrrr", month: "mm", day: "dd" },
  cy: { year: "bbbb", month: "mm", day: "dd" },
  da: { year: "åååå", month: "mm", day: "dd" },
  de: { year: "jjjj", month: "mm", day: "tt" },
  dsb: { year: "llll", month: "mm", day: "źź" },
  el: { year: "εεεε", month: "μμ", day: "ηη" },
  en: { year: "yyyy", month: "mm", day: "dd" },
  eo: { year: "jjjj", month: "mm", day: "tt" },
  es: { year: "aaaa", month: "mm", day: "dd" },
  et: { year: "aaaa", month: "kk", day: "pp" },
  eu: { year: "uuuu", month: "hh", day: "ee" },
  fa: { year: "سال", month: "ماه", day: "روز" },
  ff: { year: "hhhh", month: "ll", day: "ññ" },
  fi: { year: "vvvv", month: "kk", day: "pp" },
  fr: { year: "aaaa", month: "mm", day: "jj" },
  fy: { year: "jjjj", month: "mm", day: "dd" },
  ga: { year: "bbbb", month: "mm", day: "ll" },
  gd: { year: "bbbb", month: "mm", day: "ll" },
  gl: { year: "aaaa", month: "mm", day: "dd" },
  he: { year: "שנה", month: "חודש", day: "יום" },
  hr: { year: "gggg", month: "mm", day: "dd" },
  hsb: { year: "llll", month: "mm", day: "dd" },
  hu: { year: "éééé", month: "hh", day: "nn" },
  ia: { year: "aaaa", month: "mm", day: "dd" },
  id: { year: "tttt", month: "bb", day: "hh" },
  it: { year: "aaaa", month: "mm", day: "gg" },
  ja: { year: " 年 ", month: "月", day: "日" },
  ka: { year: "წწწწ", month: "თთ", day: "რრ" },
  kk: { year: "жжжж", month: "аа", day: "кк" },
  kn: { year: "ವವವವ", month: "ಮಿಮೀ", day: "ದಿದಿ" },
  ko: { year: "연도", month: "월", day: "일" },
  lb: { year: "jjjj", month: "mm", day: "dd" },
  lo: { year: "ປປປປ", month: "ດດ", day: "ວວ" },
  lt: { year: "mmmm", month: "mm", day: "dd" },
  lv: { year: "gggg", month: "mm", day: "dd" },
  meh: { year: "aaaa", month: "mm", day: "dd" },
  ml: { year: "വർഷം", month: "മാസം", day: "തീയതി" },
  ms: { year: "tttt", month: "mm", day: "hh" },
  nl: { year: "jjjj", month: "mm", day: "dd" },
  nn: { year: "åååå", month: "mm", day: "dd" },
  no: { year: "åååå", month: "mm", day: "dd" },
  oc: { year: "aaaa", month: "mm", day: "jj" },
  pl: { year: "rrrr", month: "mm", day: "dd" },
  pt: { year: "aaaa", month: "mm", day: "dd" },
  rm: { year: "oooo", month: "mm", day: "dd" },
  ro: { year: "aaaa", month: "ll", day: "zz" },
  ru: { year: "гггг", month: "мм", day: "дд" },
  sc: { year: "aaaa", month: "mm", day: "dd" },
  scn: { year: "aaaa", month: "mm", day: "jj" },
  sk: { year: "rrrr", month: "mm", day: "dd" },
  sl: { year: "llll", month: "mm", day: "dd" },
  sr: { year: "гггг", month: "мм", day: "дд" },
  sv: { year: "åååå", month: "mm", day: "dd" },
  szl: { year: "rrrr", month: "mm", day: "dd" },
  tg: { year: "сссс", month: "мм", day: "рр" },
  th: { year: "ปปปป", month: "ดด", day: "วว" },
  tr: { year: "yyyy", month: "aa", day: "gg" },
  uk: { year: "рррр", month: "мм", day: "дд" },
  "zh-CN": { year: "年", month: "月", day: "日" },
  "zh-TW": { year: "年", month: "月", day: "日" }
};
function getPlaceholderObj(locale) {
  if (!isSupportedLocale(locale)) {
    const localeLanguage = getLocaleLanguage(locale);
    if (!isSupportedLocale(localeLanguage)) {
      return placeholders.en;
    } else {
      return placeholders[localeLanguage];
    }
  } else {
    return placeholders[locale];
  }
}
function getPlaceholder(field, value, locale) {
  if (isPlaceholderField(field)) {
    return getPlaceholderObj(locale)[field];
  }
  if (isDefaultField(field)) {
    return value;
  }
  if (isTimeField(field)) {
    return "––";
  }
  return "";
}
function isSupportedLocale(locale) {
  return supportedLocales.includes(locale);
}
function isPlaceholderField(field) {
  return placeholderFields.includes(field);
}
function isTimeField(field) {
  return field === "hour" || field === "minute" || field === "second";
}
function isDefaultField(field) {
  return field === "era" || field === "dayPeriod";
}
function getLocaleLanguage(locale) {
  if (Intl.Locale) {
    return new Intl.Locale(locale).language;
  }
  return locale.split("-")[0];
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/announcer.js
function initAnnouncer() {
  if (!isBrowser)
    return null;
  let el = document.querySelector("[data-melt-announcer]");
  if (!isHTMLElement(el)) {
    const div = document.createElement("div");
    div.style.cssText = styleToString({
      border: "0px",
      clip: "rect(0px, 0px, 0px, 0px)",
      "clip-path": "inset(50%)",
      height: "1px",
      margin: "-1px",
      overflow: "hidden",
      padding: "0px",
      position: "absolute",
      "white-space": "nowrap",
      width: "1px"
    });
    div.setAttribute("data-melt-announcer", "");
    div.appendChild(createLog("assertive"));
    div.appendChild(createLog("polite"));
    el = div;
    document.body.insertBefore(el, document.body.firstChild);
  }
  function createLog(kind) {
    const log = document.createElement("div");
    log.role = "log";
    log.ariaLive = kind;
    log.setAttribute("aria-relevant", "additions");
    return log;
  }
  function getLog(kind) {
    if (!isHTMLElement(el))
      return null;
    const log = el.querySelector(`[aria-live="${kind}"]`);
    if (!isHTMLElement(log))
      return null;
    return log;
  }
  return {
    getLog
  };
}
function getAnnouncer() {
  const announcer = initAnnouncer();
  function announce(value, kind = "assertive", timeout = 7500) {
    if (!announcer || !isBrowser)
      return;
    const log = announcer.getLog(kind);
    const content = document.createElement("div");
    if (typeof value === "number") {
      value = value.toString();
    } else if (value === null) {
      value = "Empty";
    } else {
      value = value.trim();
    }
    content.innerText = value;
    if (kind === "assertive") {
      log == null ? void 0 : log.replaceChildren(content);
    } else {
      log == null ? void 0 : log.appendChild(content);
    }
    return setTimeout(() => {
      content.remove();
    }, timeout);
  }
  return {
    announce
  };
}

// node_modules/@melt-ui/svelte/dist/builders/date-field/_internal/parts.js
var DATE_SEGMENT_PARTS = ["day", "month", "year"];
var TIME_SEGMENT_PARTS = ["hour", "minute", "second", "dayPeriod"];
var NON_EDITABLE_SEGMENT_PARTS = ["literal", "timeZoneName"];
var EDITABLE_SEGMENT_PARTS = [...DATE_SEGMENT_PARTS, ...TIME_SEGMENT_PARTS];
var ALL_SEGMENT_PARTS = [
  ...EDITABLE_SEGMENT_PARTS,
  ...NON_EDITABLE_SEGMENT_PARTS
];
var ALL_EXCEPT_LITERAL_PARTS = ALL_SEGMENT_PARTS.filter((part) => part !== "literal");

// node_modules/@melt-ui/svelte/dist/builders/date-field/_internal/helpers.js
function initializeSegmentValues(granularity) {
  const calendarDateTimeGranularities = ["hour", "minute", "second"];
  const initialParts = EDITABLE_SEGMENT_PARTS.map((part) => {
    if (part === "dayPeriod") {
      return [part, "AM"];
    }
    return [part, null];
  }).filter(([key]) => {
    if (key === "literal" || key === null)
      return false;
    if (granularity === "day") {
      return !calendarDateTimeGranularities.includes(key);
    } else {
      return true;
    }
  });
  return Object.fromEntries(initialParts);
}
function createContentObj(props) {
  const { segmentValues, formatter, locale, dateRef } = props;
  const content = Object.keys(segmentValues).reduce((obj, part) => {
    if (!isSegmentPart(part))
      return obj;
    if ("hour" in segmentValues && part === "dayPeriod") {
      const value = segmentValues[part];
      if (!isNull(value)) {
        obj[part] = value;
      } else {
        obj[part] = getPlaceholder(part, "AM", locale);
      }
    } else {
      obj[part] = getPartContent(part);
    }
    return obj;
  }, {});
  function getPartContent(part) {
    if ("hour" in segmentValues) {
      const value = segmentValues[part];
      if (!isNull(value)) {
        return formatter.part(dateRef.set({ [part]: value }), part, {
          hourCycle: props.hourCycle === 24 ? "h24" : void 0
        });
      } else {
        return getPlaceholder(part, "", locale);
      }
    } else {
      if (isDateSegmentPart(part)) {
        const value = segmentValues[part];
        if (!isNull(value)) {
          return formatter.part(dateRef.set({ [part]: value }), part);
        } else {
          return getPlaceholder(part, "", locale);
        }
      }
      return "";
    }
  }
  return content;
}
function createContentArr(props) {
  const { granularity, dateRef, formatter, contentObj, hideTimeZone, hourCycle } = props;
  const parts = formatter.toParts(dateRef, getOptsByGranularity(granularity, hourCycle));
  const segmentContentArr = parts.map((part) => {
    const defaultParts = ["literal", "dayPeriod", "timeZoneName", null];
    if (defaultParts.includes(part.type) || !isSegmentPart(part.type)) {
      return {
        part: part.type,
        value: part.value
      };
    }
    return {
      part: part.type,
      value: contentObj[part.type]
    };
  }).filter((segment) => {
    if (isNull(segment.part) || isNull(segment.value))
      return false;
    if (segment.part === "timeZoneName" && (!isZonedDateTime(dateRef) || hideTimeZone)) {
      return false;
    }
    return true;
  });
  return segmentContentArr;
}
function createContent(props) {
  const contentObj = createContentObj(props);
  const contentArr = createContentArr({
    contentObj,
    ...props
  });
  return {
    obj: contentObj,
    arr: contentArr
  };
}
function getOptsByGranularity(granularity, hourCycle) {
  const opts = {
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
    hour: "2-digit",
    minute: "2-digit",
    second: "2-digit",
    timeZoneName: "short",
    hourCycle: hourCycle === 24 ? "h24" : void 0,
    hour12: hourCycle === 24 ? false : void 0
  };
  if (granularity === "day") {
    delete opts.second;
    delete opts.hour;
    delete opts.minute;
    delete opts.timeZoneName;
  }
  if (granularity === "hour") {
    delete opts.minute;
  }
  if (granularity === "minute") {
    delete opts.second;
  }
  return opts;
}
function initSegmentStates() {
  return EDITABLE_SEGMENT_PARTS.reduce((acc, key) => {
    acc[key] = {
      lastKeyZero: false,
      hasLeftFocus: true,
      hasTouched: false
    };
    return acc;
  }, {});
}
function isDateSegmentPart(part) {
  return DATE_SEGMENT_PARTS.includes(part);
}
function isSegmentPart(part) {
  return EDITABLE_SEGMENT_PARTS.includes(part);
}
function isAnySegmentPart(part) {
  return ALL_SEGMENT_PARTS.includes(part);
}
function getUsedSegments(id) {
  if (!isBrowser)
    return [];
  const usedSegments = getSegments(id).map((el) => el.dataset.segment).filter((part) => {
    return EDITABLE_SEGMENT_PARTS.includes(part);
  });
  return usedSegments;
}
function getValueFromSegments(props) {
  const { segmentObj, id, dateRef } = props;
  const usedSegments = getUsedSegments(id);
  let date = dateRef;
  usedSegments.forEach((part) => {
    if ("hour" in segmentObj) {
      const value = segmentObj[part];
      if (isNull(value))
        return;
      date = date.set({ [part]: segmentObj[part] });
      return;
    } else if (isDateSegmentPart(part)) {
      const value = segmentObj[part];
      if (isNull(value))
        return;
      date = date.set({ [part]: segmentObj[part] });
      return;
    }
  });
  return date;
}
function areAllSegmentsFilled(segmentValues, id) {
  const usedSegments = getUsedSegments(id);
  return usedSegments.every((part) => {
    if ("hour" in segmentValues) {
      return segmentValues[part] !== null;
    } else if (isDateSegmentPart(part)) {
      return segmentValues[part] !== null;
    }
  });
}
function getPartFromNode(node) {
  const part = node.dataset.segment;
  if (!isAnySegmentPart(part))
    return null;
  return part;
}
function isDateAndTimeSegmentObj(obj) {
  if (typeof obj !== "object" || obj === null) {
    return false;
  }
  return Object.entries(obj).every(([key, value]) => {
    const validKey = TIME_SEGMENT_PARTS.includes(key) || DATE_SEGMENT_PARTS.includes(key);
    const validValue = key === "dayPeriod" ? value === "AM" || value === "PM" || value === null : typeof value === "number" || value === null;
    return validKey && validValue;
  });
}
function inferGranularity(value, granularity) {
  if (granularity) {
    return granularity;
  }
  if (hasTime(value)) {
    return "minute";
  }
  return "day";
}
function isAcceptableSegmentKey(key) {
  const acceptableSegmentKeys = [
    kbd.ENTER,
    kbd.ARROW_UP,
    kbd.ARROW_DOWN,
    kbd.ARROW_LEFT,
    kbd.ARROW_RIGHT,
    kbd.BACKSPACE,
    kbd.SPACE
  ];
  if (acceptableSegmentKeys.includes(key))
    return true;
  if (isNumberString(key))
    return true;
  return false;
}
function syncSegmentValues(props) {
  const { value, updatingDayPeriod, segmentValues, formatter } = props;
  const dateValues = DATE_SEGMENT_PARTS.map((part) => {
    return [part, value[part]];
  });
  if ("hour" in value) {
    const timeValues = TIME_SEGMENT_PARTS.map((part) => {
      if (part === "dayPeriod") {
        const $updatingDayPeriod = get_store_value(updatingDayPeriod);
        if ($updatingDayPeriod) {
          return [part, $updatingDayPeriod];
        } else {
          return [part, formatter.dayPeriod(toDate(value))];
        }
      }
      return [part, value[part]];
    });
    const mergedSegmentValues = [...dateValues, ...timeValues];
    segmentValues.set(Object.fromEntries(mergedSegmentValues));
    updatingDayPeriod.set(null);
    return;
  }
  segmentValues.set(Object.fromEntries(dateValues));
}
function isFirstSegment(id, fieldId) {
  if (!isBrowser)
    return false;
  const segments = getSegments(fieldId);
  return segments.length ? segments[0].id === id : false;
}
function setDescription(id, formatter, value) {
  if (!isBrowser)
    return;
  const valueString = formatter.selectedDate(value);
  const el = document.getElementById(id);
  if (!el) {
    const div = document.createElement("div");
    div.style.cssText = styleToString({
      display: "none"
    });
    div.id = id;
    div.innerText = `Selected Date: ${valueString}`;
    document.body.appendChild(div);
  } else {
    el.innerText = `Selected Date: ${valueString}`;
  }
}
function removeDescriptionElement(id) {
  if (!isBrowser)
    return;
  const el = document.getElementById(id);
  if (!el)
    return;
  document.body.removeChild(el);
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/field.js
function handleSegmentNavigation(e, fieldId) {
  const currentTarget = e.currentTarget;
  if (!isHTMLElement(currentTarget))
    return;
  const { prev: prev2, next: next2 } = getPrevNextSegments(currentTarget, fieldId);
  if (e.key === kbd.ARROW_LEFT) {
    if (!prev2)
      return;
    prev2.focus();
  } else if (e.key === kbd.ARROW_RIGHT) {
    if (!next2)
      return;
    next2.focus();
  }
}
function getNextSegment(node, segments) {
  const index = segments.indexOf(node);
  if (index === segments.length - 1 || index === -1)
    return null;
  const nextIndex = index + 1;
  const nextSegment = segments[nextIndex];
  return nextSegment;
}
function getPrevSegment(node, segments) {
  const index = segments.indexOf(node);
  if (index === 0 || index === -1)
    return null;
  const prevIndex = index - 1;
  const prevSegment = segments[prevIndex];
  return prevSegment;
}
function getPrevNextSegments(node, fieldId) {
  const segments = getSegments(fieldId);
  if (!segments.length) {
    return {
      next: null,
      prev: null
    };
  }
  return {
    next: getNextSegment(node, segments),
    prev: getPrevSegment(node, segments)
  };
}
function moveToNextSegment(e, fieldId) {
  const node = e.currentTarget;
  if (!isHTMLElement(node))
    return;
  const { next: next2 } = getPrevNextSegments(node, fieldId);
  if (!next2)
    return;
  next2.focus();
}
function isSegmentNavigationKey(key) {
  if (key === kbd.ARROW_RIGHT || key === kbd.ARROW_LEFT)
    return true;
  return false;
}
function getSegments(id) {
  const inputContainer = document.getElementById(id);
  if (!isHTMLElement(inputContainer))
    return [];
  const segments = Array.from(inputContainer.querySelectorAll("[data-segment]")).filter((el) => {
    if (!isHTMLElement(el))
      return false;
    const segment = el.dataset.segment;
    if (segment === "trigger")
      return true;
    if (!isAnySegmentPart(segment) || segment === "literal")
      return false;
    return true;
  });
  return segments;
}
function getFirstSegment(id) {
  const segments = getSegments(id);
  return segments[0];
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/calendar.js
function isCalendarCell(node) {
  if (!isHTMLElement(node))
    return false;
  if (!node.hasAttribute("data-melt-calendar-cell"))
    return false;
  return true;
}
function getDaysBetween(start, end) {
  const days = [];
  let dCurrent = start.add({ days: 1 });
  const dEnd = end;
  while (dCurrent.compare(dEnd) < 0) {
    days.push(dCurrent);
    dCurrent = dCurrent.add({ days: 1 });
  }
  return days;
}
function createMonth(props) {
  const { dateObj, weekStartsOn, fixedWeeks, locale } = props;
  const daysInMonth = getDaysInMonth(dateObj);
  const datesArray = Array.from({ length: daysInMonth }, (_, i) => dateObj.set({ day: i + 1 }));
  const firstDayOfMonth = $14e0f24ef4ac5c92$export$a5a3b454ada2268e(dateObj);
  const lastDayOfMonth = $14e0f24ef4ac5c92$export$a2258d9c4118825c(dateObj);
  const lastSunday = getLastFirstDayOfWeek(firstDayOfMonth, weekStartsOn, locale);
  const nextSaturday = getNextLastDayOfWeek(lastDayOfMonth, weekStartsOn, locale);
  const lastMonthDays = getDaysBetween(lastSunday.subtract({ days: 1 }), firstDayOfMonth);
  const nextMonthDays = getDaysBetween(lastDayOfMonth, nextSaturday.add({ days: 1 }));
  const totalDays = lastMonthDays.length + datesArray.length + nextMonthDays.length;
  if (fixedWeeks && totalDays < 42) {
    const extraDays = 42 - totalDays;
    let startFrom = nextMonthDays[nextMonthDays.length - 1];
    if (!startFrom) {
      startFrom = dateObj.add({ months: 1 }).set({ day: 1 });
    }
    const extraDaysArray = Array.from({ length: extraDays }, (_, i) => {
      const incr = i + 1;
      return startFrom.add({ days: incr });
    });
    nextMonthDays.push(...extraDaysArray);
  }
  const allDays = lastMonthDays.concat(datesArray, nextMonthDays);
  const weeks = chunk(allDays, 7);
  return {
    value: dateObj,
    dates: allDays,
    weeks
  };
}
function createMonths(props) {
  const { numberOfMonths, dateObj, ...monthProps } = props;
  const months = [];
  if (!numberOfMonths || numberOfMonths === 1) {
    months.push(createMonth({
      ...monthProps,
      dateObj
    }));
    return months;
  }
  months.push(createMonth({
    ...monthProps,
    dateObj
  }));
  for (let i = 1; i < numberOfMonths; i++) {
    const nextMonth = dateObj.add({ months: i });
    months.push(createMonth({
      ...monthProps,
      dateObj: nextMonth
    }));
  }
  return months;
}
function getSelectableCells(calendarId) {
  const node = document.getElementById(calendarId);
  if (!node)
    return [];
  const selectableSelector = `[data-melt-calendar-cell]:not([data-disabled]):not([data-outside-visible-months])`;
  return Array.from(node.querySelectorAll(selectableSelector)).filter((el) => isHTMLElement(el));
}
function setPlaceholderToNodeValue(node, placeholder) {
  const cellValue = node.getAttribute("data-value");
  if (!cellValue)
    return;
  placeholder.set(parseStringToDateValue(cellValue, get_store_value(placeholder)));
}

// node_modules/@melt-ui/svelte/dist/builders/calendar/create.js
var defaults10 = {
  isDateDisabled: void 0,
  isDateUnavailable: void 0,
  value: void 0,
  preventDeselect: false,
  numberOfMonths: 1,
  pagedNavigation: false,
  weekStartsOn: 0,
  fixedWeeks: false,
  calendarLabel: "Event Date",
  locale: "en",
  minValue: void 0,
  maxValue: void 0,
  disabled: false,
  readonly: false,
  weekdayFormat: "narrow"
};
var { name: name5 } = createElHelpers("calendar");
var calendarIdParts = ["calendar", "accessibleHeading"];
function createCalendar(props) {
  const withDefaults = { ...defaults10, ...props };
  const options = toWritableStores({
    ...omit(withDefaults, "value", "placeholder", "multiple", "ids"),
    multiple: withDefaults.multiple ?? false
  });
  const { preventDeselect, numberOfMonths, pagedNavigation, weekStartsOn, fixedWeeks, calendarLabel, locale, minValue, maxValue, multiple, isDateUnavailable, disabled, readonly: readonly2, weekdayFormat } = options;
  const ids = toWritableStores({ ...generateIds(calendarIdParts), ...withDefaults.ids });
  const defaultDate = getDefaultDate({
    defaultPlaceholder: withDefaults.defaultPlaceholder,
    defaultValue: withDefaults.defaultValue
  });
  const formatter = createFormatter(withDefaults.locale);
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults.onValueChange);
  const placeholderWritable = withDefaults.placeholder ?? writable(withDefaults.defaultPlaceholder ?? defaultDate);
  const placeholder = dateStore(overridable(placeholderWritable, withDefaults.onPlaceholderChange), withDefaults.defaultPlaceholder ?? defaultDate);
  const months = withGet(writable(createMonths({
    dateObj: placeholder.get(),
    weekStartsOn: withDefaults.weekStartsOn,
    locale: withDefaults.locale,
    fixedWeeks: withDefaults.fixedWeeks,
    numberOfMonths: withDefaults.numberOfMonths
  })));
  const visibleMonths = withGet.derived([months], ([$months]) => {
    return $months.map((month) => {
      return month.value;
    });
  });
  const isOutsideVisibleMonths = derived([visibleMonths], ([$visibleMonths]) => {
    return (date) => {
      return !$visibleMonths.some((month) => $14e0f24ef4ac5c92$export$a18c89cbd24170ff(date, month));
    };
  });
  const isNextButtonDisabled = withGet.derived([months, maxValue, disabled], ([$months, $maxValue, $disabled]) => {
    if (!$maxValue || !$months.length)
      return false;
    if ($disabled)
      return true;
    const lastMonthInView = $months[$months.length - 1].value;
    const firstMonthOfNextPage = lastMonthInView.add({ months: 1 }).set({ day: 1 });
    return isAfter(firstMonthOfNextPage, $maxValue);
  });
  const isPrevButtonDisabled = withGet.derived([months, minValue, disabled], ([$months, $minValue, $disabled]) => {
    if (!$minValue || !$months.length)
      return false;
    if ($disabled)
      return true;
    const firstMonthInView = $months[0].value;
    const lastMonthOfPrevPage = firstMonthInView.subtract({ months: 1 }).set({ day: 35 });
    return isBefore(lastMonthOfPrevPage, $minValue);
  });
  const isDateDisabled = withGet.derived([options.isDateDisabled, minValue, maxValue, disabled], ([$isDateDisabled, $minValue, $maxValue, $disabled]) => {
    return (date) => {
      if (($isDateDisabled == null ? void 0 : $isDateDisabled(date)) || $disabled)
        return true;
      if ($minValue && isBefore(date, $minValue))
        return true;
      if ($maxValue && isBefore($maxValue, date))
        return true;
      return false;
    };
  });
  const isDateSelected = derived([value], ([$value]) => {
    return (date) => {
      if (Array.isArray($value)) {
        return $value.some((d) => $14e0f24ef4ac5c92$export$ea39ec197993aef0(d, date));
      } else if (!$value) {
        return false;
      } else {
        return $14e0f24ef4ac5c92$export$ea39ec197993aef0($value, date);
      }
    };
  });
  const isInvalid = derived([value, isDateDisabled, options.isDateUnavailable], ([$value, $isDateDisabled, $isDateUnavailable]) => {
    if (Array.isArray($value)) {
      if (!$value.length)
        return false;
      for (const date of $value) {
        if ($isDateDisabled == null ? void 0 : $isDateDisabled(date))
          return true;
        if ($isDateUnavailable == null ? void 0 : $isDateUnavailable(date))
          return true;
      }
    } else {
      if (!$value)
        return false;
      if ($isDateDisabled == null ? void 0 : $isDateDisabled($value))
        return true;
      if ($isDateUnavailable == null ? void 0 : $isDateUnavailable($value))
        return true;
    }
    return false;
  });
  let announcer = getAnnouncer();
  const headingValue = withGet.derived([months, locale], ([$months, $locale]) => {
    if (!$months.length)
      return "";
    if ($locale !== formatter.getLocale()) {
      formatter.setLocale($locale);
    }
    if ($months.length === 1) {
      const month = $months[0].value;
      return `${formatter.fullMonthAndYear(toDate(month))}`;
    }
    const startMonth = toDate($months[0].value);
    const endMonth = toDate($months[$months.length - 1].value);
    const startMonthName = formatter.fullMonth(startMonth);
    const endMonthName = formatter.fullMonth(endMonth);
    const startMonthYear = formatter.fullYear(startMonth);
    const endMonthYear = formatter.fullYear(endMonth);
    const content = startMonthYear === endMonthYear ? `${startMonthName} - ${endMonthName} ${endMonthYear}` : `${startMonthName} ${startMonthYear} - ${endMonthName} ${endMonthYear}`;
    return content;
  });
  const fullCalendarLabel = withGet.derived([headingValue, calendarLabel], ([$headingValue, $calendarLabel]) => {
    return `${$calendarLabel}, ${$headingValue}`;
  });
  const calendar = makeElement(name5(), {
    stores: [fullCalendarLabel, isInvalid, disabled, readonly2, ids.calendar],
    returned: ([$fullCalendarLabel, $isInvalid, $disabled, $readonly, $calendarId]) => {
      return {
        id: $calendarId,
        role: "application",
        "aria-label": $fullCalendarLabel,
        "data-invalid": $isInvalid ? "" : void 0,
        "data-disabled": $disabled ? "" : void 0,
        "data-readonly": $readonly ? "" : void 0
      };
    },
    action: (node) => {
      createAccessibleHeading(node, fullCalendarLabel.get());
      announcer = getAnnouncer();
      const unsubKb = addMeltEventListener(node, "keydown", handleCalendarKeydown);
      return {
        destroy() {
          unsubKb();
        }
      };
    }
  });
  const heading = makeElement(name5("heading"), {
    stores: [disabled],
    returned: ([$disabled]) => {
      return {
        "aria-hidden": true,
        "data-disabled": $disabled ? "" : void 0
      };
    }
  });
  const grid = makeElement(name5("grid"), {
    stores: [readonly2, disabled],
    returned: ([$readonly, $disabled]) => {
      return {
        tabindex: -1,
        role: "grid",
        "aria-readonly": $readonly ? "true" : void 0,
        "aria-disabled": $disabled ? "true" : void 0,
        "data-readonly": $readonly ? "" : void 0,
        "data-disabled": $disabled ? "" : void 0
      };
    }
  });
  const prevButton = makeElement(name5("prevButton"), {
    stores: [isPrevButtonDisabled],
    returned: ([$isPrevButtonDisabled]) => {
      const disabled2 = $isPrevButtonDisabled;
      return {
        role: "button",
        type: "button",
        "aria-label": "Previous",
        "aria-disabled": disabled2 ? "true" : void 0,
        "data-disabled": disabled2 ? "" : void 0,
        disabled: disabled2 ? true : void 0
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        if (isPrevButtonDisabled.get())
          return;
        prevPage();
      }));
      return {
        destroy: unsub
      };
    }
  });
  const nextButton = makeElement(name5("nextButton"), {
    stores: [isNextButtonDisabled],
    returned: ([$isNextButtonDisabled]) => {
      const disabled2 = $isNextButtonDisabled;
      return {
        role: "button",
        type: "button",
        "aria-label": "Next",
        "aria-disabled": disabled2 ? "true" : void 0,
        "data-disabled": disabled2 ? "" : void 0,
        disabled: disabled2 ? true : void 0
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        if (isNextButtonDisabled.get())
          return;
        nextPage();
      }));
      return {
        destroy: unsub
      };
    }
  });
  const cell = makeElement(name5("cell"), {
    stores: [
      isDateSelected,
      isDateDisabled,
      isDateUnavailable,
      isOutsideVisibleMonths,
      placeholder
    ],
    returned: ([$isDateSelected, $isDateDisabled, $isDateUnavailable, $isOutsideVisibleMonths, $placeholder]) => {
      return (cellValue, monthValue) => {
        const cellDate = toDate(cellValue);
        const isDisabled = $isDateDisabled == null ? void 0 : $isDateDisabled(cellValue);
        const isUnavailable = $isDateUnavailable == null ? void 0 : $isDateUnavailable(cellValue);
        const isDateToday = $14e0f24ef4ac5c92$export$629b0a497aa65267(cellValue, $14e0f24ef4ac5c92$export$aa8b41735afcabd2());
        const isOutsideMonth = !$14e0f24ef4ac5c92$export$a18c89cbd24170ff(cellValue, monthValue);
        const isOutsideVisibleMonths2 = $isOutsideVisibleMonths(cellValue);
        const isFocusedDate = $14e0f24ef4ac5c92$export$ea39ec197993aef0(cellValue, $placeholder);
        const isSelectedDate = $isDateSelected(cellValue);
        const labelText = formatter.custom(cellDate, {
          weekday: "long",
          month: "long",
          day: "numeric",
          year: "numeric"
        });
        return {
          role: "button",
          "aria-label": labelText,
          "aria-selected": isSelectedDate ? true : void 0,
          "aria-disabled": isOutsideMonth || isDisabled || isUnavailable ? true : void 0,
          "data-selected": isSelectedDate ? true : void 0,
          "data-value": cellValue.toString(),
          "data-disabled": isDisabled || isOutsideMonth ? "" : void 0,
          "data-unavailable": isUnavailable ? "" : void 0,
          "data-today": isDateToday ? "" : void 0,
          "data-outside-month": isOutsideMonth ? "" : void 0,
          "data-outside-visible-months": isOutsideVisibleMonths2 ? "" : void 0,
          "data-focused": isFocusedDate ? "" : void 0,
          tabindex: isFocusedDate ? 0 : isOutsideMonth || isDisabled ? void 0 : -1
        };
      };
    },
    action: (node) => {
      const getElArgs = () => {
        const value2 = node.getAttribute("data-value");
        const label = node.getAttribute("data-label");
        const disabled2 = node.hasAttribute("data-disabled");
        return {
          value: value2,
          label: label ?? node.textContent ?? null,
          disabled: disabled2 ? true : false
        };
      };
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        const args = getElArgs();
        if (args.disabled)
          return;
        if (!args.value)
          return;
        handleCellClick(parseStringToDateValue(args.value, placeholder.get()));
      }));
      return {
        destroy: unsub
      };
    }
  });
  effect([locale], ([$locale]) => {
    if (formatter.getLocale() === $locale)
      return;
    formatter.setLocale($locale);
  });
  effect([placeholder], ([$placeholder]) => {
    if (!isBrowser || !$placeholder)
      return;
    const $visibleMonths = visibleMonths.get();
    if ($visibleMonths.some((month) => $14e0f24ef4ac5c92$export$a18c89cbd24170ff(month, $placeholder))) {
      return;
    }
    const $weekStartsOn = weekStartsOn.get();
    const $locale = locale.get();
    const $fixedWeeks = fixedWeeks.get();
    const $numberOfMonths = numberOfMonths.get();
    const defaultMonthProps = {
      weekStartsOn: $weekStartsOn,
      locale: $locale,
      fixedWeeks: $fixedWeeks,
      numberOfMonths: $numberOfMonths
    };
    months.set(createMonths({
      ...defaultMonthProps,
      dateObj: $placeholder
    }));
  });
  effect([weekStartsOn, locale, fixedWeeks, numberOfMonths], ([$weekStartsOn, $locale, $fixedWeeks, $numberOfMonths]) => {
    const $placeholder = placeholder.get();
    if (!isBrowser || !$placeholder)
      return;
    const defaultMonthProps = {
      weekStartsOn: $weekStartsOn,
      locale: $locale,
      fixedWeeks: $fixedWeeks,
      numberOfMonths: $numberOfMonths
    };
    months.set(createMonths({
      ...defaultMonthProps,
      dateObj: $placeholder
    }));
  });
  effect([fullCalendarLabel], ([$fullCalendarLabel]) => {
    if (!isBrowser)
      return;
    const node = document.getElementById(ids.accessibleHeading.get());
    if (!isHTMLElement(node))
      return;
    node.textContent = $fullCalendarLabel;
  });
  effect([value], ([$value]) => {
    if (Array.isArray($value) && $value.length) {
      const lastValue = $value[$value.length - 1];
      if (lastValue && placeholder.get() !== lastValue) {
        placeholder.set(lastValue);
      }
    } else if (!Array.isArray($value) && $value && placeholder.get() !== $value) {
      placeholder.set($value);
    }
  });
  const weekdays = derived([months, weekdayFormat, locale], ([$months, $weekdayFormat, _]) => {
    if (!$months.length)
      return [];
    return $months[0].weeks[0].map((date) => {
      return formatter.dayOfWeek(toDate(date), $weekdayFormat);
    });
  });
  function createAccessibleHeading(node, label) {
    if (!isBrowser)
      return;
    const div = document.createElement("div");
    div.style.cssText = styleToString({
      border: "0px",
      clip: "rect(0px, 0px, 0px, 0px)",
      "clip-path": "inset(50%)",
      height: "1px",
      margin: "-1px",
      overflow: "hidden",
      padding: "0px",
      position: "absolute",
      "white-space": "nowrap",
      width: "1px"
    });
    const h2 = document.createElement("div");
    h2.textContent = label;
    h2.id = ids.accessibleHeading.get();
    h2.role = "heading";
    h2.ariaLevel = "2";
    node.insertBefore(div, node.firstChild);
    div.appendChild(h2);
  }
  function nextPage() {
    const $months = months.get();
    const $numberOfMonths = numberOfMonths.get();
    if (pagedNavigation.get()) {
      const firstMonth = $months[0].value;
      placeholder.set(firstMonth.add({ months: $numberOfMonths }));
    } else {
      const firstMonth = $months[0].value;
      const newMonths = createMonths({
        dateObj: firstMonth.add({ months: 1 }),
        weekStartsOn: weekStartsOn.get(),
        locale: locale.get(),
        fixedWeeks: fixedWeeks.get(),
        numberOfMonths: $numberOfMonths
      });
      months.set(newMonths);
      placeholder.set(newMonths[0].value.set({ day: 1 }));
    }
  }
  function prevPage() {
    const $months = months.get();
    const $numberOfMonths = numberOfMonths.get();
    if (pagedNavigation.get()) {
      const firstMonth = $months[0].value;
      placeholder.set(firstMonth.subtract({ months: $numberOfMonths }));
    } else {
      const firstMonth = $months[0].value;
      const newMonths = createMonths({
        dateObj: firstMonth.subtract({ months: 1 }),
        weekStartsOn: weekStartsOn.get(),
        locale: locale.get(),
        fixedWeeks: fixedWeeks.get(),
        numberOfMonths: $numberOfMonths
      });
      months.set(newMonths);
      placeholder.set(newMonths[0].value.set({ day: 1 }));
    }
  }
  function nextYear() {
    placeholder.add({ years: 1 });
  }
  function prevYear() {
    placeholder.subtract({ years: 1 });
  }
  const ARROW_KEYS = [kbd.ARROW_DOWN, kbd.ARROW_UP, kbd.ARROW_LEFT, kbd.ARROW_RIGHT];
  function setYear(year) {
    placeholder.setDate({ year });
  }
  function setMonth(month) {
    placeholder.setDate({ month });
  }
  function handleCellClick(date) {
    const $readonly = readonly2.get();
    if ($readonly)
      return;
    const $isDateDisabled = isDateDisabled.get();
    const $isUnavailable = options.isDateUnavailable.get();
    if (($isDateDisabled == null ? void 0 : $isDateDisabled(date)) || ($isUnavailable == null ? void 0 : $isUnavailable(date)))
      return;
    value.update((prev2) => {
      const $multiple = multiple.get();
      if ($multiple) {
        return handleMultipleUpdate(prev2, date);
      } else {
        const next2 = handleSingleUpdate(prev2, date);
        if (!next2) {
          announcer.announce("Selected date is now empty.", "polite", 5e3);
        } else {
          announcer.announce(`Selected Date: ${formatter.selectedDate(next2, false)}`, "polite");
        }
        return next2;
      }
    });
  }
  function handleSingleUpdate(prev2, date) {
    if (Array.isArray(prev2))
      throw new Error("Invalid value for multiple prop.");
    if (!prev2)
      return date;
    const $preventDeselect = preventDeselect.get();
    if (!$preventDeselect && $14e0f24ef4ac5c92$export$ea39ec197993aef0(prev2, date)) {
      placeholder.set(date);
      return void 0;
    }
    return date;
  }
  function handleMultipleUpdate(prev2, date) {
    if (!prev2)
      return [date];
    if (!Array.isArray(prev2))
      throw new Error("Invalid value for multiple prop.");
    const index = prev2.findIndex((d) => $14e0f24ef4ac5c92$export$ea39ec197993aef0(d, date));
    const $preventDeselect = preventDeselect.get();
    if (index === -1) {
      return [...prev2, date];
    } else if ($preventDeselect) {
      return prev2;
    } else {
      const next2 = prev2.filter((d) => !$14e0f24ef4ac5c92$export$ea39ec197993aef0(d, date));
      if (!next2.length) {
        placeholder.set(date);
        return void 0;
      }
      return next2;
    }
  }
  const SELECT_KEYS = [kbd.ENTER, kbd.SPACE];
  function handleCalendarKeydown(e) {
    const currentCell = e.target;
    if (!isCalendarCell(currentCell))
      return;
    if (!ARROW_KEYS.includes(e.key) && !SELECT_KEYS.includes(e.key))
      return;
    e.preventDefault();
    if (e.key === kbd.ARROW_DOWN) {
      shiftFocus(currentCell, 7);
    }
    if (e.key === kbd.ARROW_UP) {
      shiftFocus(currentCell, -7);
    }
    if (e.key === kbd.ARROW_LEFT) {
      shiftFocus(currentCell, -1);
    }
    if (e.key === kbd.ARROW_RIGHT) {
      shiftFocus(currentCell, 1);
    }
    if (e.key === kbd.SPACE || e.key === kbd.ENTER) {
      const cellValue = currentCell.getAttribute("data-value");
      if (!cellValue)
        return;
      handleCellClick(parseStringToDateValue(cellValue, placeholder.get()));
    }
  }
  function shiftFocus(node, add) {
    const candidateCells = getSelectableCells(ids.calendar.get());
    if (!candidateCells.length)
      return;
    const index = candidateCells.indexOf(node);
    const nextIndex = index + add;
    if (isValidIndex(nextIndex, candidateCells)) {
      const nextCell = candidateCells[nextIndex];
      setPlaceholderToNodeValue(nextCell, placeholder);
      return nextCell.focus();
    }
    if (nextIndex < 0) {
      if (isPrevButtonDisabled.get())
        return;
      const $months = months.get();
      const firstMonth = $months[0].value;
      const $numberOfMonths = numberOfMonths.get();
      placeholder.set(firstMonth.subtract({ months: $numberOfMonths }));
      tick().then(() => {
        const newCandidateCells = getSelectableCells(ids.calendar.get());
        if (!newCandidateCells.length) {
          return;
        }
        const newIndex = newCandidateCells.length - Math.abs(nextIndex);
        if (isValidIndex(newIndex, newCandidateCells)) {
          const newCell = newCandidateCells[newIndex];
          setPlaceholderToNodeValue(newCell, placeholder);
          return newCell.focus();
        }
      });
    }
    if (nextIndex >= candidateCells.length) {
      if (isNextButtonDisabled.get())
        return;
      const $months = months.get();
      const firstMonth = $months[0].value;
      const $numberOfMonths = numberOfMonths.get();
      placeholder.set(firstMonth.add({ months: $numberOfMonths }));
      tick().then(() => {
        const newCandidateCells = getSelectableCells(ids.calendar.get());
        if (!newCandidateCells.length) {
          return;
        }
        const newIndex = nextIndex - candidateCells.length;
        if (isValidIndex(newIndex, newCandidateCells)) {
          const nextCell = newCandidateCells[newIndex];
          return nextCell.focus();
        }
      });
    }
  }
  const _isDateDisabled = derived([isDateDisabled, placeholder, minValue, maxValue, disabled], ([$isDateDisabled, $placeholder, $minValue, $maxValue, $disabled]) => {
    return (date) => {
      if (($isDateDisabled == null ? void 0 : $isDateDisabled(date)) || $disabled)
        return true;
      if ($minValue && isBefore(date, $minValue))
        return true;
      if ($maxValue && isAfter(date, $maxValue))
        return true;
      if (!$14e0f24ef4ac5c92$export$a18c89cbd24170ff(date, $placeholder))
        return true;
      return false;
    };
  });
  const _isDateUnavailable = derived(isDateUnavailable, ($isDateUnavailable) => {
    return (date) => $isDateUnavailable == null ? void 0 : $isDateUnavailable(date);
  });
  return {
    elements: {
      calendar,
      heading,
      grid,
      cell,
      nextButton,
      prevButton
    },
    states: {
      placeholder: placeholder.toWritable(),
      months,
      value,
      weekdays,
      headingValue
    },
    helpers: {
      nextPage,
      prevPage,
      nextYear,
      prevYear,
      setYear,
      setMonth,
      isDateDisabled: _isDateDisabled,
      isDateSelected,
      isDateUnavailable: _isDateUnavailable
    },
    options,
    ids
  };
}

// node_modules/@melt-ui/svelte/dist/builders/date-field/create.js
var defaults11 = {
  isDateUnavailable: void 0,
  value: void 0,
  hourCycle: void 0,
  locale: "en",
  granularity: void 0,
  hideTimeZone: false,
  disabled: false,
  readonly: false,
  readonlySegments: void 0,
  name: void 0,
  required: false,
  minValue: void 0,
  maxValue: void 0
};
var prefix = "dateField";
var { name: name6 } = createElHelpers(prefix);
var dateFieldIdParts = [
  "field",
  "label",
  "description",
  "validation",
  "day",
  "month",
  "year",
  "hour",
  "minute",
  "second",
  "dayPeriod",
  "timeZoneName"
];
function createDateField(props) {
  const withDefaults = { ...defaults11, ...props };
  const options = toWritableStores(omit(withDefaults, "value", "placeholder", "ids"));
  const { locale, granularity, hourCycle, hideTimeZone, isDateUnavailable, disabled, readonly: readonly2, readonlySegments, name: nameStore, required, minValue, maxValue } = options;
  const defaultDate = getDefaultDate({
    defaultPlaceholder: withDefaults.defaultPlaceholder,
    granularity: withDefaults.granularity,
    defaultValue: withDefaults.defaultValue
  });
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults.onValueChange);
  const isInvalid = derived([value, isDateUnavailable, minValue, maxValue], ([$value, $isDateUnavailable, $minValue, $maxValue]) => {
    if (!$value)
      return false;
    if ($isDateUnavailable == null ? void 0 : $isDateUnavailable($value))
      return true;
    if ($minValue && isBefore($value, $minValue))
      return true;
    if ($maxValue && isBefore($maxValue, $value))
      return true;
    return false;
  });
  const placeholderWritable = withDefaults.placeholder ?? writable(withDefaults.defaultPlaceholder ?? defaultDate);
  const placeholder = dateStore(overridable(placeholderWritable, withDefaults.onPlaceholderChange), withDefaults.defaultPlaceholder ?? defaultDate);
  const inferredGranularity = withGet.derived([placeholder, granularity], ([$placeholder, $granularity]) => {
    if ($granularity) {
      return $granularity;
    } else {
      return inferGranularity($placeholder, $granularity);
    }
  });
  const formatter = createFormatter(locale.get());
  const initialSegments = initializeSegmentValues(inferredGranularity.get());
  const segmentValues = withGet.writable(structuredClone(initialSegments));
  let announcer = getAnnouncer();
  const updatingDayPeriod = writable(null);
  const readonlySegmentsSet = withGet(derived(readonlySegments, ($readonlySegments) => new Set($readonlySegments)));
  const ids = toWritableStores({ ...generateIds(dateFieldIdParts), ...withDefaults.ids });
  const idValues = derived([
    ids.field,
    ids.label,
    ids.description,
    ids.validation,
    ids.day,
    ids.month,
    ids.year,
    ids.hour,
    ids.minute,
    ids.second,
    ids.dayPeriod,
    ids.timeZoneName
  ], ([$fieldId, $labelId, $descriptionId, $validationId, $dayId, $monthId, $yearId, $hourId, $minuteId, $secondId, $dayPeriodId, $timeZoneNameId]) => {
    return {
      field: $fieldId,
      label: $labelId,
      description: $descriptionId,
      validation: $validationId,
      day: $dayId,
      month: $monthId,
      year: $yearId,
      hour: $hourId,
      minute: $minuteId,
      second: $secondId,
      dayPeriod: $dayPeriodId,
      timeZoneName: $timeZoneNameId
    };
  });
  const defaultSegmentAttrs = {
    role: "spinbutton",
    contenteditable: true,
    tabindex: 0,
    spellcheck: false,
    inputmode: "numeric",
    autocorrect: "off",
    enterkeyhint: "next",
    style: styleToString({
      "caret-color": "transparent"
    })
  };
  const states = initSegmentStates();
  const allSegmentContent = derived([segmentValues, locale, inferredGranularity, hideTimeZone, hourCycle], ([$segmentValues, $locale, $inferredGranularity, $hideTimeZone, $hourCycle]) => {
    return createContent({
      segmentValues: $segmentValues,
      formatter,
      locale: $locale,
      granularity: $inferredGranularity,
      dateRef: placeholder.get(),
      hideTimeZone: $hideTimeZone,
      hourCycle: $hourCycle
    });
  });
  const segmentContents = derived(allSegmentContent, ($allSegmentContent) => $allSegmentContent.arr);
  const segmentContentsObj = derived(allSegmentContent, ($allSegmentContent) => $allSegmentContent.obj);
  const label = makeElement(name6("label"), {
    stores: [isInvalid, disabled, ids.label],
    returned: ([$isInvalid, $disabled, $labelId]) => {
      return {
        id: $labelId,
        "data-invalid": $isInvalid ? "" : void 0,
        "data-disabled": $disabled ? "" : void 0
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        const firstSegment = getFirstSegment(ids.field.get());
        if (!firstSegment)
          return;
        sleep(1).then(() => firstSegment.focus());
      }), addMeltEventListener(node, "mousedown", (e) => {
        if (!e.defaultPrevented && e.detail > 1) {
          e.preventDefault();
        }
      }));
      return {
        destroy: unsub
      };
    }
  });
  const validation = makeElement(name6("validation"), {
    stores: [isInvalid, ids.validation],
    returned: ([$isInvalid, $validationId]) => {
      const validStyle = styleToString({
        display: "none"
      });
      return {
        id: $validationId,
        "data-invalid": $isInvalid ? "" : void 0,
        style: $isInvalid ? void 0 : validStyle
      };
    }
  });
  const hiddenInput = createHiddenInput({
    prefix,
    value: derived(value, ($value) => ($value == null ? void 0 : $value.toString()) ?? ""),
    name: nameStore,
    disabled,
    required
  });
  const fieldIdDeps = derived([ids.field, ids.label, ids.description, ids.label], ([$fieldId, $labelId, $descriptionId, $validationId]) => {
    return {
      field: $fieldId,
      label: $labelId,
      description: $descriptionId,
      validation: $validationId
    };
  });
  const field = makeElement(name6("field"), {
    stores: [value, isInvalid, disabled, readonly2, fieldIdDeps],
    returned: ([$value, $isInvalid, $disabled, $readonly, $ids]) => {
      const describedBy = $value ? `${$ids.description}${$isInvalid ? ` ${$ids.validation}` : ""}` : `${$ids.description}`;
      return {
        role: "group",
        id: $ids.field,
        "aria-labelledby": $ids.label,
        "aria-describedby": describedBy,
        "aria-disabled": $disabled ? "true" : void 0,
        "aria-readonly": $readonly ? "true" : void 0,
        "data-invalid": $isInvalid ? "" : void 0,
        "data-disabled": $disabled ? "" : void 0
      };
    },
    // even if we don't need the element we need to specify it
    // or TS will complain when svelte tries to pass it
    action: (_node) => {
      announcer = getAnnouncer();
      return {
        destroy() {
          removeDescriptionElement(ids.description.get());
        }
      };
    }
  });
  const segmentBuilders = {
    day: {
      attrs: daySegmentAttrs,
      action: daySegmentAction
    },
    month: {
      attrs: monthSegmentAttrs,
      action: monthSegmentAction
    },
    year: {
      attrs: yearSegmentAttrs,
      action: yearSegmentAction
    },
    hour: {
      attrs: hourSegmentAttrs,
      action: hourSegmentAction
    },
    minute: {
      attrs: minuteSegmentAttrs,
      action: minuteSegmentAction
    },
    second: {
      attrs: secondSegmentAttrs,
      action: secondSegmentAction
    },
    dayPeriod: {
      attrs: dayPeriodSegmentAttrs,
      action: dayPeriodSegmentAction
    },
    literal: {
      attrs: literalSegmentAttrs,
      action: literalSegmentAction
    },
    timeZoneName: {
      attrs: timeZoneSegmentAttrs,
      action: timeZoneSegmentAction
    }
  };
  const segment = makeElement(name6("segment"), {
    stores: [
      segmentValues,
      hourCycle,
      placeholder,
      value,
      isInvalid,
      disabled,
      readonly2,
      readonlySegmentsSet,
      idValues,
      locale
    ],
    returned: ([$segmentValues, $hourCycle, $placeholder, $value, $isInvalid, $disabled, $readonly, $readonlySegmentsSet, $idValues, _]) => {
      const props2 = {
        segmentValues: $segmentValues,
        hourCycle: $hourCycle,
        placeholder: $placeholder,
        ids: $idValues
      };
      return (part) => {
        const inReadonlySegments = $readonlySegmentsSet.has(part);
        const defaultAttrs = {
          ...getSegmentAttrs(part, props2),
          "aria-invalid": $isInvalid ? "true" : void 0,
          "aria-disabled": $disabled ? "true" : void 0,
          "aria-readonly": $readonly || inReadonlySegments ? "true" : void 0,
          "data-invalid": $isInvalid ? "" : void 0,
          "data-disabled": $disabled ? "" : void 0,
          "data-segment": `${part}`
        };
        if (part === "literal") {
          return defaultAttrs;
        }
        const id = $idValues[part];
        const hasDescription = isFirstSegment(id, $idValues.field) || $value;
        const describedBy = hasDescription ? `${hasDescription} ${$isInvalid ? $idValues.validation : ""}` : void 0;
        return {
          ...defaultAttrs,
          id: $idValues[part],
          "aria-labelledby": getLabelledBy(part),
          contenteditable: $readonly || inReadonlySegments || $disabled ? false : true,
          "aria-describedby": describedBy,
          tabindex: $disabled ? void 0 : 0
        };
      };
    },
    action: (node) => getSegmentAction(node)
  });
  function updateSegment(part, cb) {
    if (disabled.get() || readonly2.get() || readonlySegmentsSet.get().has(part))
      return;
    segmentValues.update((prev2) => {
      const dateRef = placeholder.get();
      if (isDateAndTimeSegmentObj(prev2)) {
        const pVal = prev2[part];
        const castCb = cb;
        if (part === "month") {
          const next3 = castCb(pVal);
          if (part === "month" && next3 !== null && prev2.day !== null) {
            const date = dateRef.set({ month: next3 });
            const daysInMonth = getDaysInMonth(toDate(date));
            if (prev2.day > daysInMonth) {
              prev2.day = daysInMonth;
            }
          }
          return {
            ...prev2,
            [part]: next3
          };
        } else if (part === "dayPeriod") {
          const next3 = castCb(pVal);
          updatingDayPeriod.set(next3);
          const date = placeholder.get();
          if ("hour" in date) {
            const trueHour = date.hour;
            if (next3 === "AM") {
              if (trueHour >= 12) {
                prev2.hour = trueHour - 12;
              }
            } else if (next3 === "PM") {
              if (trueHour < 12) {
                prev2.hour = trueHour + 12;
              }
            }
          }
          return {
            ...prev2,
            [part]: next3
          };
        } else if (part === "hour") {
          const next3 = castCb(pVal);
          if (next3 !== null && prev2.dayPeriod !== null) {
            const dayPeriod = formatter.dayPeriod(toDate(dateRef.set({ hour: next3 })));
            if (dayPeriod === "AM" || dayPeriod === "PM") {
              prev2.dayPeriod = dayPeriod;
            }
          }
          return {
            ...prev2,
            [part]: next3
          };
        }
        const next2 = castCb(pVal);
        return {
          ...prev2,
          [part]: next2
        };
      } else if (isDateSegmentPart(part)) {
        const pVal = prev2[part];
        const castCb = cb;
        const next2 = castCb(pVal);
        if (part === "month" && next2 !== null && prev2.day !== null) {
          const date = dateRef.set({ month: next2 });
          const daysInMonth = getDaysInMonth(toDate(date));
          if (prev2.day > daysInMonth) {
            prev2.day = daysInMonth;
          }
        }
        return {
          ...prev2,
          [part]: next2
        };
      }
      return prev2;
    });
    const $segmentValues = segmentValues.get();
    const $fieldId = ids.field.get();
    if (areAllSegmentsFilled($segmentValues, $fieldId)) {
      value.set(getValueFromSegments({
        segmentObj: $segmentValues,
        id: $fieldId,
        dateRef: placeholder.get()
      }));
      updatingDayPeriod.set(null);
    } else {
      value.set(void 0);
      segmentValues.set($segmentValues);
    }
  }
  function handleSegmentKeydown(e, part) {
    const $disabled = disabled.get();
    if (e.key !== kbd.TAB) {
      e.preventDefault();
    }
    if ($disabled)
      return;
    const segmentKeydownHandlers = {
      day: handleDaySegmentKeydown,
      month: handleMonthSegmentKeydown,
      year: handleYearSegmentKeydown,
      hour: handleHourSegmentKeydown,
      minute: handleMinuteSegmentKeydown,
      second: handleSecondSegmentKeydown,
      dayPeriod: handleDayPeriodSegmentKeydown,
      timeZoneName: handleTimeZoneSegmentKeydown
    };
    segmentKeydownHandlers[part](e);
  }
  function handleSegmentClick(e) {
    const $disabled = disabled.get();
    if ($disabled) {
      e.preventDefault();
      return;
    }
  }
  function daySegmentAttrs(props2) {
    const { segmentValues: segmentValues2, placeholder: placeholder2, ids: ids2 } = props2;
    const isEmpty = segmentValues2.day === null;
    const date = segmentValues2.day ? placeholder2.set({ day: segmentValues2.day }) : placeholder2;
    const valueNow = date.day;
    const valueMin = 1;
    const valueMax = getDaysInMonth(toDate(date));
    const valueText = isEmpty ? "Empty" : `${valueNow}`;
    return {
      ...defaultSegmentAttrs,
      id: ids2.day,
      "aria-label": `day,`,
      "aria-valuemin": valueMin,
      "aria-valuemax": valueMax,
      "aria-valuenow": valueNow,
      "aria-valuetext": valueText
    };
  }
  function daySegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "day")), addMeltEventListener(node, "focusout", () => states.day.hasLeftFocus = true), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleDaySegmentKeydown(e) {
    if (!isAcceptableSegmentKey(e.key)) {
      return;
    }
    const $segmentMonthValue = segmentValues.get().month;
    const $placeholder = placeholder.get();
    const daysInMonth = $segmentMonthValue ? getDaysInMonth($placeholder.set({ month: $segmentMonthValue })) : getDaysInMonth($placeholder);
    if (e.key === kbd.ARROW_UP) {
      updateSegment("day", (prev2) => {
        if (prev2 === null) {
          const next3 = $placeholder.day;
          announcer.announce(next3);
          return next3;
        }
        const next2 = $placeholder.set({ day: prev2 }).cycle("day", 1).day;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    if (e.key === kbd.ARROW_DOWN) {
      updateSegment("day", (prev2) => {
        if (prev2 === null) {
          const next3 = $placeholder.day;
          announcer.announce(next3);
          return next3;
        }
        const next2 = $placeholder.set({ day: prev2 }).cycle("day", -1).day;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    const $fieldId = ids.field.get();
    if (isNumberString(e.key)) {
      const num = parseInt(e.key);
      let moveToNext = false;
      updateSegment("day", (prev2) => {
        const max2 = daysInMonth;
        const maxStart = Math.floor(max2 / 10);
        if (states.day.hasLeftFocus) {
          prev2 = null;
          states.day.hasLeftFocus = false;
        }
        if (prev2 === null) {
          if (num === 0) {
            states.day.lastKeyZero = true;
            return null;
          }
          if (states.day.lastKeyZero || num > maxStart) {
            moveToNext = true;
          }
          states.day.lastKeyZero = false;
          return num;
        }
        const digits = prev2.toString().length;
        const total = parseInt(prev2.toString() + num.toString());
        if (digits === 2 || total > max2) {
          if (num > maxStart || total > max2) {
            moveToNext = true;
          }
          announcer.announce(num);
          return num;
        }
        moveToNext = true;
        announcer.announce(total);
        return total;
      });
      if (moveToNext) {
        moveToNextSegment(e, $fieldId);
      }
    }
    if (e.key === kbd.BACKSPACE) {
      const currentTarget = e.currentTarget;
      if (!isHTMLElement(currentTarget))
        return;
      updateSegment("day", (prev2) => {
        if (prev2 === null)
          return null;
        const str = prev2.toString();
        if (str.length === 1)
          return null;
        return parseInt(str.slice(0, -1));
      });
    }
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, $fieldId);
    }
  }
  function monthSegmentAttrs(props2) {
    const { segmentValues: segmentValues2, placeholder: placeholder2, ids: ids2 } = props2;
    const isEmpty = segmentValues2.month === null;
    const date = segmentValues2.month ? placeholder2.set({ month: segmentValues2.month }) : placeholder2;
    const valueNow = date.month;
    const valueMin = 1;
    const valueMax = 12;
    const valueText = isEmpty ? "Empty" : `${valueNow} - ${formatter.fullMonth(toDate(date))}`;
    return {
      ...defaultSegmentAttrs,
      id: ids2.month,
      "aria-label": "month, ",
      contenteditable: true,
      "aria-valuemin": valueMin,
      "aria-valuemax": valueMax,
      "aria-valuenow": valueNow,
      "aria-valuetext": valueText
    };
  }
  function monthSegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "month")), addMeltEventListener(node, "focusout", () => states.month.hasLeftFocus = true), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleMonthSegmentKeydown(e) {
    if (!isAcceptableSegmentKey(e.key)) {
      return;
    }
    const $placeholder = placeholder.get();
    function getMonthAnnouncement(month) {
      return `${month} - ${formatter.fullMonth(toDate($placeholder.set({ month })))}`;
    }
    const max2 = 12;
    states.month.hasTouched = true;
    if (e.key === kbd.ARROW_UP) {
      updateSegment("month", (prev2) => {
        if (prev2 === null) {
          const next3 = $placeholder.month;
          announcer.announce(getMonthAnnouncement(next3));
          return next3;
        }
        const next2 = $placeholder.set({ month: prev2 }).cycle("month", 1);
        announcer.announce(getMonthAnnouncement(next2.month));
        return next2.month;
      });
      return;
    }
    if (e.key === kbd.ARROW_DOWN) {
      updateSegment("month", (prev2) => {
        if (prev2 === null) {
          const next3 = $placeholder.month;
          announcer.announce(getMonthAnnouncement(next3));
          return next3;
        }
        const next2 = $placeholder.set({ month: prev2 }).cycle("month", -1).month;
        announcer.announce(getMonthAnnouncement(next2));
        return next2;
      });
      return;
    }
    const $fieldId = ids.field.get();
    if (isNumberString(e.key)) {
      const num = parseInt(e.key);
      let moveToNext = false;
      updateSegment("month", (prev2) => {
        const maxStart = Math.floor(max2 / 10);
        if (states.month.hasLeftFocus) {
          prev2 = null;
          states.month.hasLeftFocus = false;
        }
        if (prev2 === null) {
          if (num === 0) {
            states.month.lastKeyZero = true;
            announcer.announce(null);
            return null;
          }
          if (states.month.lastKeyZero || num > maxStart) {
            moveToNext = true;
          }
          states.month.lastKeyZero = false;
          announcer.announce(num);
          return num;
        }
        const digits = prev2.toString().length;
        const total = parseInt(prev2.toString() + num.toString());
        if (digits === 2 || total > max2) {
          if (num > maxStart) {
            moveToNext = true;
          }
          announcer.announce(num);
          return num;
        }
        moveToNext = true;
        announcer.announce(total);
        return total;
      });
      if (moveToNext) {
        moveToNextSegment(e, $fieldId);
      }
    }
    if (e.key === kbd.BACKSPACE) {
      states.month.hasLeftFocus = false;
      updateSegment("month", (prev2) => {
        if (prev2 === null) {
          announcer.announce(null);
          return null;
        }
        const str = prev2.toString();
        if (str.length === 1) {
          announcer.announce(null);
          return null;
        }
        const next2 = parseInt(str.slice(0, -1));
        announcer.announce(getMonthAnnouncement(next2));
        return next2;
      });
    }
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, $fieldId);
    }
  }
  function yearSegmentAttrs(props2) {
    const { segmentValues: segmentValues2, placeholder: placeholder2, ids: ids2 } = props2;
    const isEmpty = segmentValues2.year === null;
    const date = segmentValues2.year ? placeholder2.set({ year: segmentValues2.year }) : placeholder2;
    const valueMin = 1;
    const valueMax = 9999;
    const valueNow = date.year;
    const valueText = isEmpty ? "Empty" : `${valueNow}`;
    return {
      ...defaultSegmentAttrs,
      id: ids2.year,
      "aria-label": "year, ",
      "aria-valuemin": valueMin,
      "aria-valuemax": valueMax,
      "aria-valuenow": valueNow,
      "aria-valuetext": valueText
    };
  }
  function yearSegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "year")), addMeltEventListener(node, "focusout", () => states.year.hasLeftFocus = true), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleYearSegmentKeydown(e) {
    if (!isAcceptableSegmentKey(e.key)) {
      return;
    }
    states.year.hasTouched = true;
    const $placeholder = placeholder.get();
    if (e.key === kbd.ARROW_UP) {
      updateSegment("year", (prev2) => {
        if (prev2 === null) {
          const next3 = $placeholder.year;
          announcer.announce(next3);
          return next3;
        }
        const next2 = $placeholder.set({ year: prev2 }).cycle("year", 1).year;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    if (e.key === kbd.ARROW_DOWN) {
      updateSegment("year", (prev2) => {
        if (prev2 === null) {
          const next3 = $placeholder.year;
          announcer.announce(next3);
          return next3;
        }
        const next2 = $placeholder.set({ year: prev2 }).cycle("year", -1).year;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    const $fieldId = ids.field.get();
    if (isNumberString(e.key)) {
      let moveToNext = false;
      const num = parseInt(e.key);
      updateSegment("year", (prev2) => {
        if (states.year.hasLeftFocus) {
          prev2 = null;
          states.year.hasLeftFocus = false;
        }
        if (prev2 === null) {
          announcer.announce(num);
          return num;
        }
        const str = prev2.toString() + num.toString();
        if (str.length > 4) {
          announcer.announce(num);
          return num;
        }
        if (str.length === 4) {
          moveToNext = true;
        }
        const int = parseInt(str);
        announcer.announce(int);
        return int;
      });
      if (moveToNext) {
        moveToNextSegment(e, $fieldId);
      }
    }
    if (e.key === kbd.BACKSPACE) {
      updateSegment("year", (prev2) => {
        if (prev2 === null) {
          announcer.announce(null);
          return null;
        }
        const str = prev2.toString();
        if (str.length === 1) {
          announcer.announce(null);
          return null;
        }
        const next2 = parseInt(str.slice(0, -1));
        announcer.announce(next2);
        return next2;
      });
    }
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, $fieldId);
    }
  }
  function hourSegmentAttrs(props2) {
    const { segmentValues: segmentValues2, hourCycle: hourCycle2, placeholder: placeholder2, ids: ids2 } = props2;
    if (!("hour" in segmentValues2) || !("hour" in placeholder2))
      return {};
    const isEmpty = segmentValues2.hour === null;
    const date = segmentValues2.hour ? placeholder2.set({ hour: segmentValues2.hour }) : placeholder2;
    const valueMin = hourCycle2 === 12 ? 1 : 0;
    const valueMax = hourCycle2 === 12 ? 12 : 23;
    const valueNow = date.hour;
    const valueText = isEmpty ? "Empty" : `${valueNow} ${segmentValues2.dayPeriod ?? ""}`;
    return {
      ...defaultSegmentAttrs,
      id: ids2.hour,
      "aria-label": "hour, ",
      "aria-valuemin": valueMin,
      "aria-valuemax": valueMax,
      "aria-valuenow": valueNow,
      "aria-valuetext": valueText
    };
  }
  function hourSegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "hour")), addMeltEventListener(node, "focusout", () => states.hour.hasLeftFocus = true), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleHourSegmentKeydown(e) {
    const dateRef = placeholder.get();
    if (!isAcceptableSegmentKey(e.key) || !("hour" in dateRef)) {
      return;
    }
    states.hour.hasTouched = true;
    const $hourCycle = hourCycle.get();
    if (e.key === kbd.ARROW_UP) {
      updateSegment("hour", (prev2) => {
        if (prev2 === null) {
          const next3 = dateRef.cycle("hour", 1, { hourCycle: $hourCycle }).hour;
          announcer.announce(next3);
          return next3;
        }
        const next2 = dateRef.set({ hour: prev2 }).cycle("hour", 1, { hourCycle: $hourCycle }).hour;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    if (e.key === kbd.ARROW_DOWN) {
      updateSegment("hour", (prev2) => {
        if (prev2 === null) {
          const next3 = dateRef.cycle("hour", -1, { hourCycle: $hourCycle }).hour;
          announcer.announce(next3);
          return next3;
        }
        const next2 = dateRef.set({ hour: prev2 }).cycle("hour", -1, { hourCycle: $hourCycle }).hour;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    const $fieldId = ids.field.get();
    if (isNumberString(e.key)) {
      const num = parseInt(e.key);
      let moveToNext = false;
      updateSegment("hour", (prev2) => {
        const maxStart = Math.floor(24 / 10);
        if (states.hour.hasLeftFocus) {
          prev2 = null;
          states.hour.hasLeftFocus = false;
        }
        if (prev2 === null) {
          if (num === 0) {
            states.hour.lastKeyZero = true;
            announcer.announce(null);
            return null;
          }
          if (states.hour.lastKeyZero || num > maxStart) {
            moveToNext = true;
          }
          states.hour.lastKeyZero = false;
          announcer.announce(num);
          return num;
        }
        const digits = prev2.toString().length;
        const total = parseInt(prev2.toString() + num.toString());
        if (digits === 2 || total > 24) {
          if (num > maxStart) {
            moveToNext = true;
          }
          announcer.announce(num);
          return num;
        }
        moveToNext = true;
        announcer.announce(total);
        return total;
      });
      if (moveToNext) {
        moveToNextSegment(e, $fieldId);
      }
    }
    if (e.key === kbd.BACKSPACE) {
      states.hour.hasLeftFocus = false;
      updateSegment("hour", (prev2) => {
        if (prev2 === null) {
          announcer.announce(null);
          return null;
        }
        const str = prev2.toString();
        if (str.length === 1) {
          announcer.announce(null);
          return null;
        }
        const next2 = parseInt(str.slice(0, -1));
        announcer.announce(next2);
        return next2;
      });
    }
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, $fieldId);
    }
  }
  function minuteSegmentAttrs(props2) {
    const { segmentValues: segmentValues2, placeholder: placeholder2, ids: ids2 } = props2;
    if (!("minute" in segmentValues2) || !("minute" in placeholder2))
      return {};
    const isEmpty = segmentValues2.minute === null;
    const date = segmentValues2.minute ? placeholder2.set({ minute: segmentValues2.minute }) : placeholder2;
    const valueNow = date.minute;
    const valueMin = 0;
    const valueMax = 59;
    const valueText = isEmpty ? "Empty" : `${valueNow}`;
    return {
      ...defaultSegmentAttrs,
      id: ids2.minute,
      "aria-label": "minute, ",
      "aria-valuemin": valueMin,
      "aria-valuemax": valueMax,
      "aria-valuenow": valueNow,
      "aria-valuetext": valueText
    };
  }
  function minuteSegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "minute")), addMeltEventListener(node, "focusout", () => states.minute.hasLeftFocus = true), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleMinuteSegmentKeydown(e) {
    const dateRef = placeholder.get();
    if (!isAcceptableSegmentKey(e.key) || !("minute" in dateRef)) {
      return;
    }
    states.minute.hasTouched = true;
    const min2 = 0;
    const max2 = 59;
    if (e.key === kbd.ARROW_UP) {
      updateSegment("minute", (prev2) => {
        if (prev2 === null) {
          announcer.announce(min2);
          return min2;
        }
        const next2 = dateRef.set({ minute: prev2 }).cycle("minute", 1).minute;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    if (e.key === kbd.ARROW_DOWN) {
      updateSegment("minute", (prev2) => {
        if (prev2 === null) {
          announcer.announce(max2);
          return max2;
        }
        const next2 = dateRef.set({ minute: prev2 }).cycle("minute", -1).minute;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    const $fieldId = ids.field.get();
    if (isNumberString(e.key)) {
      const num = parseInt(e.key);
      let moveToNext = false;
      updateSegment("minute", (prev2) => {
        const maxStart = Math.floor(max2 / 10);
        if (states.minute.hasLeftFocus) {
          prev2 = null;
          states.minute.hasLeftFocus = false;
        }
        if (prev2 === null) {
          if (num === 0) {
            states.minute.lastKeyZero = true;
            announcer.announce(null);
            return 0;
          }
          if (states.minute.lastKeyZero || num > maxStart) {
            moveToNext = true;
          }
          states.minute.lastKeyZero = false;
          announcer.announce(num);
          return num;
        }
        const digits = prev2.toString().length;
        const total = parseInt(prev2.toString() + num.toString());
        if (digits === 2 || total > max2) {
          if (num > maxStart) {
            moveToNext = true;
          }
          announcer.announce(num);
          return num;
        }
        moveToNext = true;
        announcer.announce(total);
        return total;
      });
      if (moveToNext) {
        moveToNextSegment(e, $fieldId);
      }
    }
    if (e.key === kbd.BACKSPACE) {
      states.minute.hasLeftFocus = false;
      updateSegment("minute", (prev2) => {
        if (prev2 === null) {
          announcer.announce("Empty");
          return null;
        }
        const str = prev2.toString();
        if (str.length === 1) {
          announcer.announce("Empty");
          return null;
        }
        const next2 = parseInt(str.slice(0, -1));
        announcer.announce(next2);
        return next2;
      });
    }
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, $fieldId);
    }
  }
  function secondSegmentAttrs(props2) {
    const { segmentValues: segmentValues2, placeholder: placeholder2, ids: ids2 } = props2;
    if (!("second" in segmentValues2) || !("second" in placeholder2))
      return {};
    const isEmpty = segmentValues2.second === null;
    const date = segmentValues2.second ? placeholder2.set({ second: segmentValues2.second }) : placeholder2;
    const valueNow = date.second;
    const valueMin = 0;
    const valueMax = 59;
    const valueText = isEmpty ? "Empty" : `${valueNow}`;
    return {
      ...defaultSegmentAttrs,
      id: ids2.second,
      "aria-label": "second, ",
      "aria-valuemin": valueMin,
      "aria-valuemax": valueMax,
      "aria-valuenow": valueNow,
      "aria-valuetext": valueText
    };
  }
  function secondSegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "second")), addMeltEventListener(node, "focusout", () => states.second.hasLeftFocus = true), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleSecondSegmentKeydown(e) {
    const dateRef = placeholder.get();
    if (!isAcceptableSegmentKey(e.key)) {
      return;
    }
    states.second.hasTouched = true;
    const min2 = 0;
    const max2 = 59;
    if (!("second" in dateRef))
      return;
    if (e.key === kbd.ARROW_UP) {
      updateSegment("second", (prev2) => {
        if (prev2 === null) {
          announcer.announce(min2);
          return min2;
        }
        const next2 = dateRef.set({ second: prev2 }).cycle("second", 1).second;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    if (e.key === kbd.ARROW_DOWN) {
      updateSegment("second", (prev2) => {
        if (prev2 === null) {
          announcer.announce(max2);
          return max2;
        }
        const next2 = dateRef.set({ second: prev2 }).cycle("second", -1).second;
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    const $fieldId = ids.field.get();
    if (isNumberString(e.key)) {
      const num = parseInt(e.key);
      let moveToNext = false;
      updateSegment("second", (prev2) => {
        const maxStart = Math.floor(max2 / 10);
        if (states.second.hasLeftFocus) {
          prev2 = null;
          states.second.hasLeftFocus = false;
        }
        if (prev2 === null) {
          if (num === 0) {
            states.second.lastKeyZero = true;
            announcer.announce(null);
            return 0;
          }
          if (states.second.lastKeyZero || num > maxStart) {
            moveToNext = true;
          }
          states.second.lastKeyZero = false;
          announcer.announce(num);
          return num;
        }
        const digits = prev2.toString().length;
        const total = parseInt(prev2.toString() + num.toString());
        if (digits === 2 || total > max2) {
          if (num > maxStart) {
            moveToNext = true;
          }
          announcer.announce(num);
          return num;
        }
        moveToNext = true;
        announcer.announce(total);
        return total;
      });
      if (moveToNext) {
        moveToNextSegment(e, $fieldId);
      }
    }
    if (e.key === kbd.BACKSPACE) {
      states.second.hasLeftFocus = false;
      updateSegment("second", (prev2) => {
        if (prev2 === null) {
          announcer.announce(null);
          return null;
        }
        const str = prev2.toString();
        if (str.length === 1) {
          announcer.announce(null);
          return null;
        }
        const next2 = parseInt(str.slice(0, -1));
        announcer.announce(next2);
        return next2;
      });
    }
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, $fieldId);
    }
  }
  function dayPeriodSegmentAttrs(props2) {
    const { segmentValues: segmentValues2, ids: ids2 } = props2;
    if (!("dayPeriod" in segmentValues2))
      return {};
    const valueMin = 0;
    const valueMax = 12;
    const valueNow = segmentValues2.dayPeriod ?? 0;
    const valueText = segmentValues2.dayPeriod ?? "AM";
    return {
      ...defaultSegmentAttrs,
      inputmode: "text",
      id: ids2.dayPeriod,
      "aria-label": "AM/PM",
      "aria-valuemin": valueMin,
      "aria-valuemax": valueMax,
      "aria-valuenow": valueNow,
      "aria-valuetext": valueText
    };
  }
  function dayPeriodSegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "dayPeriod")), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleDayPeriodSegmentKeydown(e) {
    if (!isAcceptableSegmentKey(e.key) && e.key !== kbd.A && e.key !== kbd.P) {
      return;
    }
    if (e.key === kbd.ARROW_UP || e.key === kbd.ARROW_DOWN) {
      updateSegment("dayPeriod", (prev2) => {
        if (prev2 === "AM") {
          const next3 = "PM";
          announcer.announce(next3);
          return next3;
        }
        const next2 = "AM";
        announcer.announce(next2);
        return next2;
      });
      return;
    }
    if (e.key === kbd.BACKSPACE) {
      states.second.hasLeftFocus = false;
      updateSegment("dayPeriod", () => {
        const next2 = "AM";
        announcer.announce(next2);
        return "AM";
      });
    }
    if (e.key === "a") {
      updateSegment("dayPeriod", () => {
        const next2 = "AM";
        announcer.announce(next2);
        return "AM";
      });
    }
    if (e.key === "p") {
      updateSegment("dayPeriod", () => {
        const next2 = "PM";
        announcer.announce(next2);
        return "PM";
      });
    }
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, ids.field.get());
    }
  }
  function literalSegmentAttrs(_) {
    return {
      "aria-hidden": true,
      "data-segment": "literal"
    };
  }
  function literalSegmentAction(_) {
    return {
      destroy: noop2
    };
  }
  function timeZoneSegmentAttrs(_) {
    return {
      role: "textbox",
      "aria-label": "timezone, ",
      "data-readonly": true,
      "data-segment": "timeZoneName",
      tabindex: 0,
      style: styleToString({
        "caret-color": "transparent"
      })
    };
  }
  function timeZoneSegmentAction(node) {
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => handleSegmentKeydown(e, "timeZoneName")), addMeltEventListener(node, "click", handleSegmentClick));
    return {
      destroy() {
        unsubEvents();
      }
    };
  }
  function handleTimeZoneSegmentKeydown(e) {
    if (isSegmentNavigationKey(e.key)) {
      handleSegmentNavigation(e, ids.field.get());
    }
  }
  function getSegmentAttrs(part, props2) {
    var _a;
    return (_a = segmentBuilders[part]) == null ? void 0 : _a.attrs(props2);
  }
  function getSegmentAction(node) {
    const part = getPartFromNode(node);
    if (!part) {
      throw new Error("No segment part found");
    }
    return segmentBuilders[part].action(node);
  }
  function getLabelledBy(part) {
    return `${ids[part].get()} ${ids.label.get()}`;
  }
  effect(locale, ($locale) => {
    if (formatter.getLocale() === $locale)
      return;
    formatter.setLocale($locale);
  });
  effect(value, ($value) => {
    if ($value) {
      setDescription(ids.description.get(), formatter, $value);
    }
    if ($value && placeholder.get() !== $value) {
      placeholder.set($value);
    }
  });
  effect([value, locale], ([$value, _]) => {
    if ($value) {
      syncSegmentValues({
        value: $value,
        segmentValues,
        formatter,
        updatingDayPeriod
      });
    } else {
      segmentValues.set(structuredClone(initialSegments));
    }
  });
  const _isDateUnavailable = derived(isDateUnavailable, ($isDateUnavailable) => {
    return (date) => $isDateUnavailable == null ? void 0 : $isDateUnavailable(date);
  });
  return {
    elements: {
      field,
      segment,
      label,
      hiddenInput,
      validation
    },
    states: {
      value,
      segmentValues,
      segmentContents,
      segmentContentsObj,
      placeholder: placeholder.toWritable(),
      isInvalid
    },
    helpers: {
      isDateUnavailable: _isDateUnavailable
    },
    options,
    ids
  };
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/date/focus.js
function pickerOpenFocus(defaultEl) {
  const el = document.querySelector("[data-melt-calendar-cell][data-focused]");
  if (isHTMLElement(el)) {
    return el;
  }
  if (isHTMLElement(defaultEl)) {
    return defaultEl;
  }
  return null;
}

// node_modules/@melt-ui/svelte/dist/builders/date-picker/create.js
var defaults12 = {
  isDateDisabled: void 0,
  isDateUnavailable: void 0,
  value: void 0,
  positioning: {
    placement: "bottom"
  },
  closeOnEscape: true,
  closeOnOutsideClick: true,
  onOutsideClick: void 0,
  preventScroll: false,
  forceVisible: false,
  locale: "en",
  granularity: void 0,
  disabled: false,
  readonly: false,
  minValue: void 0,
  maxValue: void 0,
  weekdayFormat: "narrow",
  ...omit(defaults10, "isDateDisabled", "isDateUnavailable", "value", "locale", "disabled", "readonly", "minValue", "maxValue", "weekdayFormat")
};
function createDatePicker(props) {
  const withDefaults = { ...defaults12, ...props };
  const options = toWritableStores(omit(withDefaults, "value", "placeholder"));
  const dateField = createDateField({
    ...withDefaults,
    ids: withDefaults.dateFieldIds
  });
  const { states: { value, placeholder: dfPlaceholder } } = dateField;
  const calendar = createCalendar({
    ...omit(withDefaults, "onValueChange"),
    placeholder: dfPlaceholder,
    value,
    ids: withDefaults.calendarIds
  });
  const popover = createPopover({
    positioning: withDefaults.positioning,
    arrowSize: withDefaults.arrowSize,
    defaultOpen: withDefaults.defaultOpen,
    open: withDefaults.open,
    disableFocusTrap: withDefaults.disableFocusTrap,
    closeOnEscape: withDefaults.closeOnEscape,
    preventScroll: withDefaults.preventScroll,
    onOpenChange: withDefaults.onOpenChange,
    closeOnOutsideClick: withDefaults.closeOnOutsideClick,
    portal: withDefaults.portal,
    forceVisible: withDefaults.forceVisible,
    openFocus: pickerOpenFocus,
    ids: withDefaults.popoverIds,
    onOutsideClick: withDefaults.onOutsideClick
  });
  const trigger = makeElement("popover-trigger", {
    stores: [popover.elements.trigger, options.disabled],
    returned: ([$trigger, $disabled]) => {
      return {
        ...omit($trigger, "action"),
        "aria-label": "Open date picker",
        "data-segment": "trigger",
        disabled: $disabled ? true : void 0
      };
    },
    action: (node) => {
      const unsubKeydown = addMeltEventListener(node, "keydown", handleTriggerKeydown);
      const { destroy } = popover.elements.trigger(node);
      return {
        destroy() {
          destroy == null ? void 0 : destroy();
          unsubKeydown();
        }
      };
    }
  });
  const formatter = createFormatter(options.locale.get());
  effect([options.locale], ([$locale]) => {
    dateField.options.locale.set($locale);
    calendar.options.locale.set($locale);
    if (formatter.getLocale() === $locale)
      return;
    formatter.setLocale($locale);
  });
  effect([options.weekdayFormat], ([$weekdayFormat]) => {
    calendar.options.weekdayFormat.set($weekdayFormat);
  });
  effect([options.disabled], ([$disabled]) => {
    dateField.options.disabled.set($disabled);
    calendar.options.disabled.set($disabled);
  });
  effect([options.readonly], ([$readonly]) => {
    dateField.options.readonly.set($readonly);
    calendar.options.readonly.set($readonly);
  });
  effect([options.minValue], ([$minValue]) => {
    dateField.options.minValue.set($minValue);
    calendar.options.minValue.set($minValue);
  });
  effect([options.maxValue], ([$maxValue]) => {
    dateField.options.maxValue.set($maxValue);
    calendar.options.maxValue.set($maxValue);
  });
  effect([options.numberOfMonths], ([$numberOfMonths]) => {
    calendar.options.numberOfMonths.set($numberOfMonths);
  });
  effect([options.fixedWeeks], ([$fixedWeeks]) => {
    calendar.options.fixedWeeks.set($fixedWeeks);
  });
  effect([options.weekStartsOn], ([$weekStartsOn]) => {
    calendar.options.weekStartsOn.set($weekStartsOn);
  });
  const dateFieldOptions = omit(dateField.options, "locale", "disabled", "readonly", "minValue", "maxValue");
  const calendarOptions = omit(calendar.options, "locale", "disabled", "readonly", "minValue", "maxValue");
  const { states: { open } } = popover;
  const defaultDate = getDefaultDate({
    defaultPlaceholder: withDefaults.defaultPlaceholder,
    defaultValue: withDefaults.defaultValue,
    granularity: withDefaults.granularity
  });
  const placeholder = dateStore(dfPlaceholder, withDefaults.defaultPlaceholder ?? defaultDate);
  effect([open], ([$open]) => {
    if (!$open) {
      const $value = value.get();
      if ($value) {
        placeholder.set($value);
      } else {
        placeholder.reset();
      }
    }
  });
  function handleTriggerKeydown(e) {
    if (isSegmentNavigationKey(e.key)) {
      e.preventDefault();
      handleSegmentNavigation(e, dateField.ids.field.get());
    }
  }
  return {
    elements: {
      ...calendar.elements,
      ...dateField.elements,
      ...popover.elements,
      trigger
    },
    states: {
      ...dateField.states,
      ...calendar.states,
      placeholder: placeholder.toWritable(),
      value,
      ...popover.states
    },
    helpers: {
      ...calendar.helpers
    },
    options: {
      ...dateFieldOptions,
      ...calendarOptions,
      ...options,
      ...popover.options
    },
    ids: {
      dateField: dateField.ids,
      calendar: calendar.ids,
      popover: popover.ids
    }
  };
}

// node_modules/@melt-ui/svelte/dist/builders/date-range-field/_internal/helpers.js
function removeDescriptionElement2(id) {
  if (!isBrowser)
    return;
  const el = document.getElementById(id);
  if (!el)
    return;
  document.body.removeChild(el);
}

// node_modules/@melt-ui/svelte/dist/builders/date-range-field/create.js
var defaults13 = {
  isDateUnavailable: void 0,
  value: void 0,
  hourCycle: void 0,
  locale: "en",
  granularity: void 0,
  hideTimeZone: false,
  defaultValue: {
    start: void 0,
    end: void 0
  },
  startName: void 0,
  endName: void 0,
  disabled: false,
  readonly: false,
  readonlySegments: void 0,
  minValue: void 0,
  maxValue: void 0
};
var { name: name7 } = createElHelpers("dateField");
var rangeFieldIdParts = ["field", "label", "description", "validation"];
function createDateRangeField(props) {
  var _a, _b, _c, _d, _e, _f, _g;
  const withDefaults = { ...defaults13, ...props };
  const options = toWritableStores(omit(withDefaults, "value", "placeholder"));
  const generatedIds = generateIds(rangeFieldIdParts);
  const ids = toWritableStores({ ...generatedIds, ...withDefaults.ids });
  const defaultDate = getDefaultDate({
    defaultValue: (_a = withDefaults.defaultValue) == null ? void 0 : _a.start,
    defaultPlaceholder: withDefaults.defaultPlaceholder,
    granularity: withDefaults.granularity
  });
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults.onValueChange);
  const startValue = withGet.writable(((_b = value.get()) == null ? void 0 : _b.start) ?? ((_c = withDefaults.defaultValue) == null ? void 0 : _c.start));
  const endValue = withGet.writable(((_d = value.get()) == null ? void 0 : _d.end) ?? ((_e = withDefaults.defaultValue) == null ? void 0 : _e.end));
  const isCompleted = derived(value, ($value) => {
    return ($value == null ? void 0 : $value.start) && ($value == null ? void 0 : $value.end);
  });
  const placeholderWritable = withDefaults.placeholder ?? writable(withDefaults.defaultPlaceholder ?? defaultDate);
  const placeholder = dateStore(overridable(placeholderWritable, withDefaults.onPlaceholderChange), withDefaults.defaultPlaceholder ?? defaultDate);
  const startField = createDateField({
    ...omit(withDefaults, "defaultValue", "onValueChange", "startName", "endName", "readonlySegments"),
    value: startValue,
    name: withDefaults.startName,
    readonlySegments: (_f = withDefaults.readonlySegments) == null ? void 0 : _f.start,
    ids: {
      ...generatedIds,
      ...withDefaults.ids,
      ...withDefaults.startIds
    }
  });
  const endField = createDateField({
    ...omit(withDefaults, "defaultValue", "onValueChange", "endName", "startName", "readonlySegments"),
    value: endValue,
    name: withDefaults.endName,
    readonlySegments: (_g = withDefaults.readonlySegments) == null ? void 0 : _g.end,
    ids: {
      ...generatedIds,
      ...withDefaults.ids,
      ...withDefaults.endIds
    }
  });
  const { elements: { segment: startSegment, hiddenInput: startHiddenInput }, states: { isInvalid: isStartInvalid, segmentContents: startSegmentContents, segmentValues: startSegmentValues }, options: { name: startName } } = startField;
  const { elements: { segment: endSegment, hiddenInput: endHiddenInput }, states: { isInvalid: isEndInvalid, segmentContents: endSegmentContents, segmentValues: endSegmentValues }, options: { name: endName } } = endField;
  const isInvalid = derived([value, isStartInvalid, isEndInvalid, options.isDateUnavailable], ([$value, $isStartInvalid, $isEndInvalid, $isDateUnavailable]) => {
    if ($isStartInvalid || $isEndInvalid) {
      return true;
    }
    if (!($value == null ? void 0 : $value.start) || !($value == null ? void 0 : $value.end)) {
      return false;
    }
    if (!isBeforeOrSame($value == null ? void 0 : $value.start, $value == null ? void 0 : $value.end)) {
      return true;
    }
    if ($isDateUnavailable !== void 0) {
      const allValid = areAllDaysBetweenValid($value == null ? void 0 : $value.start, $value == null ? void 0 : $value.end, $isDateUnavailable, void 0);
      if (!allValid) {
        return true;
      }
    }
    return false;
  });
  const label = makeElement(name7("label"), {
    stores: [isInvalid, options.disabled, ids.label],
    returned: ([$isInvalid, $disabled, $labelId]) => {
      return {
        id: $labelId,
        "data-invalid": $isInvalid ? "" : void 0,
        "data-disabled": $disabled ? "" : void 0
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        const firstSegment = getFirstSegment(ids.field.get());
        if (!firstSegment)
          return;
        sleep(1).then(() => firstSegment.focus());
      }), addMeltEventListener(node, "mousedown", (e) => {
        if (!e.defaultPrevented && e.detail > 1) {
          e.preventDefault();
        }
      }));
      return {
        destroy: unsub
      };
    }
  });
  const fieldIdDeps = derived([ids.field, ids.label, ids.description, ids.validation], ([$fieldId, $labelId, $descriptionId, $validationId]) => {
    return {
      field: $fieldId,
      label: $labelId,
      description: $descriptionId,
      validation: $validationId
    };
  });
  const field = makeElement(name7("field"), {
    stores: [isCompleted, isInvalid, fieldIdDeps],
    returned: ([$isCompleted, $isInvalid, $ids]) => {
      const describedBy = $isCompleted ? `${$ids.description}${$isInvalid ? ` ${$ids.validation}` : ""}` : `${$ids.description}`;
      return {
        role: "group",
        id: $ids.field,
        "aria-labelledby": $ids.label,
        "aria-describedby": describedBy,
        "data-invalid": $isInvalid ? "" : void 0
      };
    },
    action: () => {
      getAnnouncer();
      return {
        destroy() {
          removeDescriptionElement2(ids.description.get());
        }
      };
    }
  });
  const validation = makeElement(name7("validation"), {
    stores: [isInvalid, ids.validation],
    returned: ([$isInvalid, $validationId]) => {
      const validStyle = styleToString({
        display: "none"
      });
      return {
        id: $validationId,
        "data-invalid": $isInvalid ? "" : void 0,
        style: $isInvalid ? void 0 : validStyle
      };
    }
  });
  const segmentContents = derived([startSegmentContents, endSegmentContents], ([$startSegmentContents, $endSegmentContents]) => {
    return {
      start: $startSegmentContents,
      end: $endSegmentContents
    };
  });
  effect([value], ([$value]) => {
    const $startValue = startValue.get();
    const $endValue = endValue.get();
    if (($value == null ? void 0 : $value.start) && ($value == null ? void 0 : $value.end)) {
      if ($value.start !== $startValue) {
        startValue.set($value.start);
      }
      if ($value.end !== $endValue) {
        endValue.set($value.end);
      }
      return;
    }
  });
  effect([startValue, endValue], ([$startValue, $endValue]) => {
    const $value = value.get();
    if ($value && ($value == null ? void 0 : $value.start) === $startValue && ($value == null ? void 0 : $value.end) === $endValue)
      return;
    if ($startValue && $endValue) {
      value.update((prev2) => {
        if ((prev2 == null ? void 0 : prev2.start) === $startValue && (prev2 == null ? void 0 : prev2.end) === $endValue) {
          return prev2;
        }
        return {
          start: $startValue,
          end: $endValue
        };
      });
    } else if ($value && ($value == null ? void 0 : $value.start) && ($value == null ? void 0 : $value.end)) {
      value.set({
        start: void 0,
        end: void 0
      });
    }
  });
  effect([options.disabled], ([$disabled]) => {
    startField.options.disabled.set($disabled);
    endField.options.disabled.set($disabled);
  });
  effect([options.readonly], ([$readonly]) => {
    startField.options.readonly.set($readonly);
    endField.options.readonly.set($readonly);
  });
  effect([options.readonlySegments], ([$readonlySegments]) => {
    startField.options.readonlySegments.set($readonlySegments == null ? void 0 : $readonlySegments.start);
    endField.options.readonlySegments.set($readonlySegments == null ? void 0 : $readonlySegments.end);
  });
  effect([options.minValue], ([$minValue]) => {
    startField.options.minValue.set($minValue);
    endField.options.minValue.set($minValue);
  });
  effect([options.maxValue], ([$maxValue]) => {
    startField.options.maxValue.set($maxValue);
    endField.options.maxValue.set($maxValue);
  });
  effect([options.granularity], ([$granularity]) => {
    startField.options.granularity.set($granularity);
    endField.options.granularity.set($granularity);
  });
  effect([options.hideTimeZone], ([$hideTimeZone]) => {
    startField.options.hideTimeZone.set($hideTimeZone);
    endField.options.hideTimeZone.set($hideTimeZone);
  });
  effect([options.hourCycle], ([$hourCycle]) => {
    startField.options.hourCycle.set($hourCycle);
    endField.options.hourCycle.set($hourCycle);
  });
  effect([options.locale], ([$locale]) => {
    startField.options.locale.set($locale);
    endField.options.locale.set($locale);
  });
  return {
    elements: {
      field,
      label,
      startSegment,
      endSegment,
      startHiddenInput,
      endHiddenInput,
      validation
    },
    states: {
      value,
      placeholder: placeholder.toWritable(),
      segmentContents,
      endSegmentValues,
      startSegmentValues,
      isInvalid
    },
    options: {
      ...options,
      endName,
      startName
    },
    ids: {
      field: ids,
      start: startField.ids,
      end: endField.ids
    }
  };
}

// node_modules/@melt-ui/svelte/dist/builders/date-range-picker/create.js
var defaults14 = {
  isDateDisabled: void 0,
  isDateUnavailable: void 0,
  value: void 0,
  positioning: {
    placement: "bottom"
  },
  closeOnEscape: true,
  closeOnOutsideClick: true,
  preventScroll: false,
  forceVisible: false,
  locale: "en",
  granularity: void 0,
  disabled: false,
  readonly: false,
  minValue: void 0,
  maxValue: void 0,
  weekdayFormat: "narrow",
  onOutsideClick: void 0
};
function createDateRangePicker(props) {
  var _a;
  const withDefaults = { ...defaults14, ...props };
  const rangeField = createDateRangeField(withDefaults);
  const { states: { value, placeholder: rfPlaceholder } } = rangeField;
  const calendar = createRangeCalendar({
    ...omit(withDefaults, "onValueChange"),
    placeholder: rfPlaceholder,
    value,
    ids: withDefaults.calendarIds
  });
  const popover = createPopover({
    positioning: withDefaults.positioning,
    arrowSize: withDefaults.arrowSize,
    defaultOpen: withDefaults.defaultOpen,
    open: withDefaults.open,
    disableFocusTrap: withDefaults.disableFocusTrap,
    closeOnEscape: withDefaults.closeOnEscape,
    preventScroll: withDefaults.preventScroll,
    onOpenChange: withDefaults.onOpenChange,
    closeOnOutsideClick: withDefaults.closeOnOutsideClick,
    portal: withDefaults.portal,
    forceVisible: withDefaults.forceVisible,
    openFocus: pickerOpenFocus,
    onOutsideClick: withDefaults.onOutsideClick
  });
  const options = toWritableStores({
    ...omit(withDefaults, "value", "placeholder")
  });
  const { locale } = options;
  const defaultDate = getDefaultDate({
    defaultValue: (_a = withDefaults.defaultValue) == null ? void 0 : _a.start,
    defaultPlaceholder: withDefaults.defaultPlaceholder,
    granularity: withDefaults.granularity
  });
  const formatter = createFormatter(locale.get());
  const placeholder = dateStore(rfPlaceholder, withDefaults.defaultPlaceholder ?? defaultDate);
  const trigger = makeElement("popover-trigger", {
    stores: [popover.elements.trigger, options.disabled],
    returned: ([$trigger, $disabled]) => {
      return {
        ...omit($trigger, "action"),
        "aria-label": "Open date picker",
        "data-segment": "trigger",
        disabled: $disabled ? true : void 0
      };
    },
    action: (node) => {
      const unsubKeydown = addMeltEventListener(node, "keydown", handleTriggerKeydown);
      const { destroy } = popover.elements.trigger(node);
      return {
        destroy() {
          destroy == null ? void 0 : destroy();
          unsubKeydown();
        }
      };
    }
  });
  effect([options.locale], ([$locale]) => {
    rangeField.options.locale.set($locale);
    calendar.options.locale.set($locale);
    if (formatter.getLocale() === $locale)
      return;
    formatter.setLocale($locale);
  });
  effect([options.weekdayFormat], ([$weekdayFormat]) => {
    calendar.options.weekdayFormat.set($weekdayFormat);
  });
  effect([options.disabled], ([$disabled]) => {
    rangeField.options.disabled.set($disabled);
    calendar.options.disabled.set($disabled);
  });
  effect([options.readonly], ([$readonly]) => {
    rangeField.options.readonly.set($readonly);
    calendar.options.readonly.set($readonly);
  });
  effect([options.minValue], ([$minValue]) => {
    rangeField.options.minValue.set($minValue);
    calendar.options.minValue.set($minValue);
  });
  effect([options.maxValue], ([$maxValue]) => {
    rangeField.options.maxValue.set($maxValue);
    calendar.options.maxValue.set($maxValue);
  });
  effect([popover.states.open], ([$open]) => {
    if (!$open) {
      const $value = value.get();
      if ($value == null ? void 0 : $value.start) {
        placeholder.set($value.start);
      } else {
        placeholder.reset();
      }
    }
  });
  effect([options.onOutsideClick], ([$onOutsideClick]) => {
    popover.options.onOutsideClick.set($onOutsideClick);
  });
  const rangeFieldOptions = omit(rangeField.options, "locale", "disabled", "readonly", "minValue", "maxValue");
  const rangeCalendarOptions = omit(calendar.options, "locale", "disabled", "readonly", "minValue", "maxValue");
  function handleTriggerKeydown(e) {
    if (isSegmentNavigationKey(e.key)) {
      e.preventDefault();
      handleSegmentNavigation(e, rangeField.ids.field.field.get());
    }
  }
  return {
    elements: {
      ...calendar.elements,
      ...rangeField.elements,
      ...popover.elements,
      trigger
    },
    states: {
      ...rangeField.states,
      ...calendar.states,
      placeholder: placeholder.toWritable(),
      value,
      ...popover.states
    },
    helpers: {
      ...calendar.helpers
    },
    options: {
      ...rangeFieldOptions,
      ...rangeCalendarOptions,
      ...options,
      ...popover.options
    },
    ids: {
      rangeField: rangeField.ids,
      calendar: calendar.ids,
      popover: popover.ids
    }
  };
}

// node_modules/@melt-ui/svelte/dist/builders/dialog/create.js
var { name: name8 } = createElHelpers("dialog");
var defaults15 = {
  preventScroll: true,
  closeOnEscape: true,
  closeOnOutsideClick: true,
  role: "dialog",
  defaultOpen: false,
  portal: void 0,
  forceVisible: false,
  openFocus: void 0,
  closeFocus: void 0,
  onOutsideClick: void 0
};
var dialogIdParts = ["content", "title", "description"];
function createDialog(props) {
  const withDefaults = { ...defaults15, ...props };
  const options = toWritableStores(omit(withDefaults, "ids"));
  const { preventScroll, closeOnEscape, closeOnOutsideClick, role, portal, forceVisible, openFocus, closeFocus, onOutsideClick } = options;
  const activeTrigger = withGet.writable(null);
  const ids = toWritableStores({
    ...generateIds(dialogIdParts),
    ...withDefaults.ids
  });
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const open = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const isVisible = derived([open, forceVisible], ([$open, $forceVisible]) => {
    return $open || $forceVisible;
  });
  let unsubScroll = noop2;
  function handleOpen(e) {
    const el = e.currentTarget;
    const triggerEl = e.currentTarget;
    if (!isHTMLElement(el) || !isHTMLElement(triggerEl))
      return;
    open.set(true);
    activeTrigger.set(triggerEl);
  }
  function handleClose() {
    open.set(false);
    handleFocus({
      prop: closeFocus.get(),
      defaultEl: activeTrigger.get()
    });
  }
  const trigger = makeElement(name8("trigger"), {
    stores: [open],
    returned: ([$open]) => {
      return {
        "aria-haspopup": "dialog",
        "aria-expanded": $open,
        type: "button"
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", (e) => {
        handleOpen(e);
      }), addMeltEventListener(node, "keydown", (e) => {
        if (e.key !== kbd.ENTER && e.key !== kbd.SPACE)
          return;
        e.preventDefault();
        handleOpen(e);
      }));
      return {
        destroy: unsub
      };
    }
  });
  const overlay = makeElement(name8("overlay"), {
    stores: [isVisible, open],
    returned: ([$isVisible, $open]) => {
      return {
        hidden: $isVisible ? void 0 : true,
        tabindex: -1,
        style: styleToString({
          display: $isVisible ? void 0 : "none"
        }),
        "aria-hidden": true,
        "data-state": $open ? "open" : "closed"
      };
    },
    action: (node) => {
      let unsubEscapeKeydown = noop2;
      if (closeOnEscape.get()) {
        const escapeKeydown = useEscapeKeydown(node, {
          handler: () => {
            handleClose();
          }
        });
        if (escapeKeydown && escapeKeydown.destroy) {
          unsubEscapeKeydown = escapeKeydown.destroy;
        }
      }
      return {
        destroy() {
          unsubEscapeKeydown();
        }
      };
    }
  });
  const content = makeElement(name8("content"), {
    stores: [isVisible, ids.content, ids.description, ids.title, open],
    returned: ([$isVisible, $contentId, $descriptionId, $titleId, $open]) => {
      return {
        id: $contentId,
        role: role.get(),
        "aria-describedby": $descriptionId,
        "aria-labelledby": $titleId,
        "aria-modal": $isVisible ? "true" : void 0,
        "data-state": $open ? "open" : "closed",
        tabindex: -1,
        hidden: $isVisible ? void 0 : true,
        style: styleToString({
          display: $isVisible ? void 0 : "none"
        })
      };
    },
    action: (node) => {
      let activate = noop2;
      let deactivate = noop2;
      const destroy = executeCallbacks(effect([open], ([$open]) => {
        if (!$open)
          return;
        const focusTrap = createFocusTrap3({
          immediate: false,
          escapeDeactivates: true,
          clickOutsideDeactivates: true,
          returnFocusOnDeactivate: false,
          fallbackFocus: node
        });
        activate = focusTrap.activate;
        deactivate = focusTrap.deactivate;
        const ac = focusTrap.useFocusTrap(node);
        if (ac && ac.destroy) {
          return ac.destroy;
        } else {
          return focusTrap.deactivate;
        }
      }), effect([closeOnOutsideClick, open], ([$closeOnOutsideClick, $open]) => {
        return useModal(node, {
          open: $open,
          closeOnInteractOutside: $closeOnOutsideClick,
          onClose() {
            handleClose();
          },
          shouldCloseOnInteractOutside(e) {
            var _a;
            (_a = onOutsideClick.get()) == null ? void 0 : _a(e);
            if (e.defaultPrevented)
              return false;
            return true;
          }
        }).destroy;
      }), effect([closeOnEscape], ([$closeOnEscape]) => {
        if (!$closeOnEscape)
          return noop2;
        const escapeKeydown = useEscapeKeydown(node, {
          handler: () => {
            handleClose();
          }
        });
        if (escapeKeydown && escapeKeydown.destroy) {
          return escapeKeydown.destroy;
        }
        return noop2;
      }), effect([isVisible], ([$isVisible]) => {
        tick().then(() => {
          if (!$isVisible) {
            deactivate();
          } else {
            activate();
          }
        });
      }));
      return {
        destroy: () => {
          unsubScroll();
          destroy();
        }
      };
    }
  });
  const portalled = makeElement(name8("portalled"), {
    stores: portal,
    returned: ($portal) => ({
      "data-portal": portalAttr($portal)
    }),
    action: (node) => {
      const unsubPortal = effect([portal], ([$portal]) => {
        if ($portal === null)
          return noop2;
        const portalDestination = getPortalDestination(node, $portal);
        if (portalDestination === null)
          return noop2;
        const portalAction = usePortal(node, portalDestination);
        if (portalAction && portalAction.destroy) {
          return portalAction.destroy;
        } else {
          return noop2;
        }
      });
      return {
        destroy() {
          unsubPortal();
        }
      };
    }
  });
  const title = makeElement(name8("title"), {
    stores: [ids.title],
    returned: ([$titleId]) => ({
      id: $titleId
    })
  });
  const description = makeElement(name8("description"), {
    stores: [ids.description],
    returned: ([$descriptionId]) => ({
      id: $descriptionId
    })
  });
  const close = makeElement(name8("close"), {
    returned: () => ({
      type: "button"
    }),
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        handleClose();
      }), addMeltEventListener(node, "keydown", (e) => {
        if (e.key !== kbd.SPACE && e.key !== kbd.ENTER)
          return;
        e.preventDefault();
        handleClose();
      }));
      return {
        destroy: unsub
      };
    }
  });
  effect([open, preventScroll], ([$open, $preventScroll]) => {
    if (!isBrowser)
      return;
    if ($preventScroll && $open)
      unsubScroll = removeScroll();
    if ($open) {
      const contentEl = document.getElementById(ids.content.get());
      handleFocus({ prop: openFocus.get(), defaultEl: contentEl });
    }
    return () => {
      if (!forceVisible.get()) {
        unsubScroll();
      }
    };
  });
  return {
    ids,
    elements: {
      content,
      trigger,
      title,
      description,
      overlay,
      close,
      portalled
    },
    states: {
      open
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/dropdown-menu/create.js
var defaults16 = {
  arrowSize: 8,
  positioning: {
    placement: "bottom"
  },
  preventScroll: true,
  closeOnEscape: true,
  closeOnOutsideClick: true,
  portal: void 0,
  loop: false,
  dir: "ltr",
  defaultOpen: false,
  forceVisible: false,
  typeahead: true,
  closeFocus: void 0,
  disableFocusFirstItem: false,
  closeOnItemClick: true,
  onOutsideClick: void 0
};
function createDropdownMenu(props) {
  const withDefaults = { ...defaults16, ...props };
  const rootOptions = toWritableStores(omit(withDefaults, "ids"));
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const rootOpen = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const rootActiveTrigger = withGet(writable(null));
  const nextFocusable = withGet(writable(null));
  const prevFocusable = withGet(writable(null));
  const { elements, builders, ids, states, options } = createMenuBuilder({
    rootOptions,
    rootOpen,
    rootActiveTrigger: withGet(rootActiveTrigger),
    nextFocusable: withGet(nextFocusable),
    prevFocusable: withGet(prevFocusable),
    selector: "dropdown-menu",
    removeScroll: true,
    ids: withDefaults.ids
  });
  return {
    ids,
    elements,
    states,
    builders,
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/link-preview/create.js
var { name: name9 } = createElHelpers("hover-card");
var defaults17 = {
  defaultOpen: false,
  openDelay: 1e3,
  closeDelay: 100,
  positioning: {
    placement: "bottom"
  },
  arrowSize: 8,
  closeOnOutsideClick: true,
  forceVisible: false,
  portal: void 0,
  closeOnEscape: true,
  onOutsideClick: void 0
};
var linkPreviewIdParts = ["trigger", "content"];
function createLinkPreview(props = {}) {
  const withDefaults = { ...defaults17, ...props };
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const open = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const hasSelection = withGet.writable(false);
  const isPointerDownOnContent = withGet.writable(false);
  const containSelection = writable(false);
  const activeTrigger = writable(null);
  const options = toWritableStores(omit(withDefaults, "ids"));
  const { openDelay, closeDelay, positioning, arrowSize, closeOnOutsideClick, forceVisible, portal, closeOnEscape, onOutsideClick } = options;
  const ids = toWritableStores({ ...generateIds(linkPreviewIdParts), ...withDefaults.ids });
  let timeout = null;
  let originalBodyUserSelect;
  const handleOpen = withGet.derived(openDelay, ($openDelay) => {
    return () => {
      if (timeout) {
        window.clearTimeout(timeout);
        timeout = null;
      }
      timeout = window.setTimeout(() => {
        open.set(true);
      }, $openDelay);
    };
  });
  const handleClose = withGet.derived([closeDelay, isPointerDownOnContent, hasSelection], ([$closeDelay, $isPointerDownOnContent, $hasSelection]) => {
    return () => {
      if (timeout) {
        window.clearTimeout(timeout);
        timeout = null;
      }
      if (!$isPointerDownOnContent && !$hasSelection) {
        timeout = window.setTimeout(() => {
          open.set(false);
        }, $closeDelay);
      }
    };
  });
  const trigger = makeElement(name9("trigger"), {
    stores: [open, ids.trigger, ids.content],
    returned: ([$open, $triggerId, $contentId]) => {
      return {
        role: "button",
        "aria-haspopup": "dialog",
        "aria-expanded": $open,
        "data-state": $open ? "open" : "closed",
        "aria-controls": $contentId,
        id: $triggerId
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "pointerenter", (e) => {
        if (isTouch(e))
          return;
        handleOpen.get()();
      }), addMeltEventListener(node, "pointerleave", (e) => {
        if (isTouch(e))
          return;
        handleClose.get()();
      }), addMeltEventListener(node, "focus", (e) => {
        if (!isElement(e.currentTarget) || !isFocusVisible(e.currentTarget))
          return;
        handleOpen.get()();
      }), addMeltEventListener(node, "blur", () => handleClose.get()()));
      return {
        destroy: unsub
      };
    }
  });
  const isVisible = derivedVisible({ open, forceVisible, activeTrigger });
  const content = makeElement(name9("content"), {
    stores: [isVisible, portal, ids.content],
    returned: ([$isVisible, $portal, $contentId]) => {
      return {
        hidden: $isVisible ? void 0 : true,
        tabindex: -1,
        style: styleToString({
          "pointer-events": $isVisible ? void 0 : "none",
          opacity: $isVisible ? 1 : 0,
          userSelect: "text",
          WebkitUserSelect: "text"
        }),
        id: $contentId,
        "data-state": $isVisible ? "open" : "closed",
        "data-portal": portalAttr($portal)
      };
    },
    action: (node) => {
      let unsub = noop2;
      const unsubTimers = () => {
        if (timeout) {
          window.clearTimeout(timeout);
        }
      };
      let unsubPopper = noop2;
      const unsubDerived = effect([isVisible, activeTrigger, positioning, closeOnOutsideClick, portal, closeOnEscape], ([$isVisible, $activeTrigger, $positioning, $closeOnOutsideClick, $portal, $closeOnEscape]) => {
        unsubPopper();
        if (!$isVisible || !$activeTrigger)
          return;
        tick().then(() => {
          const popper = usePopper(node, {
            anchorElement: $activeTrigger,
            open,
            options: {
              floating: $positioning,
              modal: {
                closeOnInteractOutside: $closeOnOutsideClick,
                onClose: () => {
                  open.set(false);
                  $activeTrigger.focus();
                },
                shouldCloseOnInteractOutside: (e) => {
                  var _a;
                  (_a = onOutsideClick.get()) == null ? void 0 : _a(e);
                  if (e.defaultPrevented)
                    return false;
                  if (isHTMLElement($activeTrigger) && $activeTrigger.contains(e.target))
                    return false;
                  return true;
                },
                open: $isVisible
              },
              portal: getPortalDestination(node, $portal),
              focusTrap: null,
              escapeKeydown: $closeOnEscape ? void 0 : null
            }
          });
          if (popper && popper.destroy) {
            unsubPopper = popper.destroy;
          }
        });
      });
      unsub = executeCallbacks(addMeltEventListener(node, "pointerdown", (e) => {
        const currentTarget = e.currentTarget;
        const target = e.target;
        if (!isHTMLElement(currentTarget) || !isHTMLElement(target))
          return;
        if (currentTarget.contains(target)) {
          containSelection.set(true);
        }
        hasSelection.set(false);
        isPointerDownOnContent.set(true);
      }), addMeltEventListener(node, "pointerenter", (e) => {
        if (isTouch(e))
          return;
        handleOpen.get()();
      }), addMeltEventListener(node, "pointerleave", (e) => {
        if (isTouch(e))
          return;
        handleClose.get()();
      }), addMeltEventListener(node, "focusout", (e) => {
        e.preventDefault();
      }));
      return {
        destroy() {
          unsub();
          unsubPopper();
          unsubTimers();
          unsubDerived();
        }
      };
    }
  });
  const arrow3 = makeElement(name9("arrow"), {
    stores: arrowSize,
    returned: ($arrowSize) => ({
      "data-arrow": true,
      style: styleToString({
        position: "absolute",
        width: `var(--arrow-size, ${$arrowSize}px)`,
        height: `var(--arrow-size, ${$arrowSize}px)`
      })
    })
  });
  effect([containSelection], ([$containSelection]) => {
    if (!isBrowser || !$containSelection)
      return;
    const body = document.body;
    const contentElement = document.getElementById(ids.content.get());
    if (!contentElement)
      return;
    originalBodyUserSelect = body.style.userSelect || body.style.webkitUserSelect;
    const originalContentUserSelect = contentElement.style.userSelect || contentElement.style.webkitUserSelect;
    body.style.userSelect = "none";
    body.style.webkitUserSelect = "none";
    contentElement.style.userSelect = "text";
    contentElement.style.webkitUserSelect = "text";
    return () => {
      body.style.userSelect = originalBodyUserSelect;
      body.style.webkitUserSelect = originalBodyUserSelect;
      contentElement.style.userSelect = originalContentUserSelect;
      contentElement.style.webkitUserSelect = originalContentUserSelect;
    };
  });
  safeOnMount(() => {
    const triggerEl = document.getElementById(ids.trigger.get());
    if (!triggerEl)
      return;
    activeTrigger.set(triggerEl);
  });
  effect([open], ([$open]) => {
    if (!isBrowser || !$open) {
      hasSelection.set(false);
      return;
    }
    const handlePointerUp = () => {
      containSelection.set(false);
      isPointerDownOnContent.set(false);
      sleep(1).then(() => {
        var _a;
        const isSelection = ((_a = document.getSelection()) == null ? void 0 : _a.toString()) !== "";
        if (isSelection) {
          hasSelection.set(true);
        }
      });
    };
    document.addEventListener("pointerup", handlePointerUp);
    const contentElement = document.getElementById(ids.content.get());
    if (!contentElement)
      return;
    const tabbables = getTabbableNodes(contentElement);
    tabbables.forEach((tabbable3) => tabbable3.setAttribute("tabindex", "-1"));
    return () => {
      document.removeEventListener("pointerup", handlePointerUp);
      hasSelection.set(false);
      isPointerDownOnContent.set(false);
    };
  });
  return {
    ids,
    elements: {
      trigger,
      content,
      arrow: arrow3
    },
    states: {
      open
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/menubar/create.js
var MENUBAR_NAV_KEYS = [kbd.ARROW_LEFT, kbd.ARROW_RIGHT, kbd.HOME, kbd.END];
var { name: name10 } = createElHelpers("menubar");
var defaults18 = {
  loop: true,
  closeOnEscape: true,
  preventScroll: false
};
var menubarIdParts = ["menubar"];
function createMenubar(props) {
  const withDefaults = { ...defaults18, ...props };
  const options = toWritableStores(omit(withDefaults, "ids"));
  const { loop, closeOnEscape, preventScroll } = options;
  const activeMenu = withGet(writable(""));
  const nextFocusable = withGet(writable(null));
  const prevFocusable = withGet(writable(null));
  const lastFocusedMenuTrigger = withGet(writable(null));
  const closeTimer = withGet(writable(0));
  let scrollRemoved = false;
  const ids = toWritableStores({ ...generateIds(menubarIdParts), ...withDefaults.ids });
  const menubar = makeElement(name10(), {
    stores: [ids.menubar],
    returned([$menubarId]) {
      return {
        role: "menubar",
        "data-melt-menubar": "",
        "data-orientation": "horizontal",
        id: $menubarId
      };
    },
    action: (node) => {
      const menuTriggers = Array.from(node.querySelectorAll("[data-melt-menubar-trigger]"));
      if (!isHTMLElement(menuTriggers[0]))
        return {};
      menuTriggers[0].tabIndex = 0;
      return {
        destroy: noop2
      };
    }
  });
  const menuDefaults = {
    positioning: {
      placement: "bottom-start"
    },
    arrowSize: 8,
    dir: "ltr",
    loop: false,
    closeOnEscape: true,
    closeOnOutsideClick: true,
    portal: void 0,
    forceVisible: false,
    defaultOpen: false,
    typeahead: true,
    closeFocus: void 0,
    disableFocusFirstItem: false,
    closeOnItemClick: true,
    onOutsideClick: void 0
  };
  const createMenu = (props2) => {
    const withDefaults2 = { ...menuDefaults, ...props2 };
    const rootOpen = withGet(writable(false));
    const rootActiveTrigger = withGet(writable(null));
    const options2 = toWritableStores(withDefaults2);
    const { positioning, portal, forceVisible, closeOnOutsideClick, onOutsideClick } = options2;
    const m = createMenuBuilder({
      rootOptions: { ...options2, preventScroll },
      rootOpen: withGet(rootOpen),
      rootActiveTrigger: withGet(rootActiveTrigger),
      nextFocusable: withGet(nextFocusable),
      prevFocusable: withGet(prevFocusable),
      selector: "menubar-menu",
      removeScroll: false
    });
    const isVisible = derivedVisible({
      open: rootOpen,
      forceVisible,
      activeTrigger: rootActiveTrigger
    });
    const menu = makeElement(name10("menu"), {
      stores: [isVisible, portal, m.ids.menu, m.ids.trigger, ids.menubar],
      returned: ([$isVisible, $portal, $menuId, $triggerId, $menubarId]) => {
        return {
          role: "menu",
          hidden: $isVisible ? void 0 : true,
          style: styleToString({
            display: $isVisible ? void 0 : "none"
          }),
          id: $menuId,
          "aria-labelledby": $triggerId,
          "data-state": $isVisible ? "open" : "closed",
          "data-melt-scope": $menubarId,
          "data-portal": portalAttr($portal),
          tabindex: -1
        };
      },
      action: (node) => {
        let unsubPopper = noop2;
        const unsubDerived = effect([rootOpen, rootActiveTrigger, positioning, portal, closeOnOutsideClick], ([$rootOpen, $rootActiveTrigger, $positioning, $portal, $closeOnOutsideClick]) => {
          unsubPopper();
          if (!($rootOpen && $rootActiveTrigger))
            return;
          tick().then(() => {
            const popper = usePopper(node, {
              anchorElement: $rootActiveTrigger,
              open: rootOpen,
              options: {
                floating: $positioning,
                portal: getPortalDestination(node, $portal),
                modal: {
                  closeOnInteractOutside: $closeOnOutsideClick,
                  shouldCloseOnInteractOutside: (e) => {
                    var _a;
                    (_a = onOutsideClick.get()) == null ? void 0 : _a(e);
                    if (e.defaultPrevented)
                      return false;
                    const target = e.target;
                    const menubarEl = document.getElementById(ids.menubar.get());
                    if (!menubarEl || !isElement(target))
                      return true;
                    if (menubarEl.contains(target))
                      return false;
                    return true;
                  },
                  onClose: () => {
                    activeMenu.set("");
                  },
                  open: $rootOpen
                }
              }
            });
            if (popper && popper.destroy) {
              unsubPopper = popper.destroy;
            }
          });
        });
        const unsubEvents = executeCallbacks(addMeltEventListener(node, "keydown", (e) => {
          const target = e.target;
          const menuEl = e.currentTarget;
          if (!isHTMLElement(menuEl) || !isHTMLElement(target))
            return;
          if (MENUBAR_NAV_KEYS.includes(e.key)) {
            handleCrossMenuNavigation(e);
          }
          const isKeyDownInside = target.closest('[role="menu"]') === menuEl;
          if (!isKeyDownInside)
            return;
          if (FIRST_LAST_KEYS.includes(e.key)) {
            handleMenuNavigation(e);
          }
          if (e.key === kbd.TAB) {
            e.preventDefault();
            rootActiveTrigger.set(null);
            rootOpen.set(false);
            handleTabNavigation(e, nextFocusable, prevFocusable);
          }
          const isCharacterKey = e.key.length === 1;
          const isModifierKey = e.ctrlKey || e.altKey || e.metaKey;
          if (!isModifierKey && isCharacterKey) {
            m.helpers.handleTypeaheadSearch(e.key, getMenuItems(menuEl));
          }
        }));
        return {
          destroy() {
            unsubDerived();
            unsubEvents();
            unsubPopper();
          }
        };
      }
    });
    const trigger = makeElement(name10("trigger"), {
      stores: [rootOpen, m.ids.menu, m.ids.trigger],
      returned: ([$rootOpen, $menuId, $triggerId]) => {
        return {
          "aria-controls": $menuId,
          "aria-expanded": $rootOpen,
          "data-state": $rootOpen ? "open" : "closed",
          id: $triggerId,
          "aria-haspopup": "menu",
          "data-orientation": "horizontal",
          role: "menuitem"
        };
      },
      action: (node) => {
        applyAttrsIfDisabled(node);
        const menubarEl = document.getElementById(ids.menubar.get());
        if (!menubarEl)
          return {};
        const menubarTriggers = Array.from(menubarEl.querySelectorAll("[data-melt-menubar-trigger]"));
        if (!menubarTriggers.length)
          return {};
        const unsubEffect = effect([lastFocusedMenuTrigger], ([$lastFocusedMenuTrigger]) => {
          if (!$lastFocusedMenuTrigger && menubarTriggers[0] === node) {
            node.tabIndex = 0;
          } else if ($lastFocusedMenuTrigger === node) {
            node.tabIndex = 0;
          } else {
            node.tabIndex = -1;
          }
        });
        if (menubarTriggers[0] === node) {
          node.tabIndex = 0;
        } else {
          node.tabIndex = -1;
        }
        const unsub = executeCallbacks(addMeltEventListener(node, "click", (e) => {
          const $rootOpen = rootOpen.get();
          const triggerEl = e.currentTarget;
          if (!isHTMLElement(triggerEl))
            return;
          handleOpen(triggerEl);
          if (!$rootOpen)
            e.preventDefault();
        }), addMeltEventListener(node, "keydown", (e) => {
          const triggerEl = e.currentTarget;
          if (!isHTMLElement(triggerEl))
            return;
          if (SELECTION_KEYS.includes(e.key) || e.key === kbd.ARROW_DOWN) {
            e.preventDefault();
            handleOpen(triggerEl);
            const menuId = triggerEl.getAttribute("aria-controls");
            if (!menuId)
              return;
            const menu2 = document.getElementById(menuId);
            if (!menu2)
              return;
            const menuItems = getMenuItems(menu2);
            if (!menuItems.length)
              return;
            handleRovingFocus(menuItems[0]);
          }
        }), addMeltEventListener(node, "pointerenter", (e) => {
          const triggerEl = e.currentTarget;
          if (!isHTMLElement(triggerEl))
            return;
          const $activeMenu = activeMenu.get();
          const $rootOpen = rootOpen.get();
          if ($activeMenu && !$rootOpen) {
            rootOpen.set(true);
            activeMenu.set(m.ids.menu.get());
            rootActiveTrigger.set(triggerEl);
          }
        }));
        return {
          destroy() {
            unsub();
            unsubEffect();
          }
        };
      }
    });
    function handleOpen(triggerEl) {
      rootOpen.update((prev2) => {
        const isOpen = !prev2;
        if (isOpen) {
          nextFocusable.set(getNextFocusable(triggerEl));
          prevFocusable.set(getPreviousFocusable(triggerEl));
          rootActiveTrigger.set(triggerEl);
          activeMenu.set(m.ids.menu.get());
        } else {
          rootActiveTrigger.set(null);
        }
        return isOpen;
      });
    }
    effect([activeMenu], ([$activeMenu]) => {
      if (!isBrowser)
        return;
      if ($activeMenu === m.ids.menu.get()) {
        if (rootOpen.get())
          return;
        const triggerEl = document.getElementById(m.ids.trigger.get());
        if (!triggerEl)
          return;
        rootActiveTrigger.set(triggerEl);
        addHighlight(triggerEl);
        rootOpen.set(true);
        return;
      }
      if ($activeMenu !== m.ids.menu.get()) {
        if (!isBrowser)
          return;
        if (rootOpen.get()) {
          const triggerEl = document.getElementById(m.ids.trigger.get());
          if (!triggerEl)
            return;
          rootActiveTrigger.set(null);
          rootOpen.set(false);
          removeHighlight(triggerEl);
        }
        return;
      }
    });
    effect([rootOpen], ([$rootOpen]) => {
      if (!isBrowser)
        return;
      const triggerEl = document.getElementById(m.ids.trigger.get());
      if (!triggerEl)
        return;
      if (!$rootOpen && activeMenu.get() === m.ids.menu.get()) {
        rootActiveTrigger.set(null);
        activeMenu.set("");
        removeHighlight(triggerEl);
        return;
      }
      if ($rootOpen) {
        lastFocusedMenuTrigger.set(triggerEl);
        addHighlight(triggerEl);
      }
    });
    safeOnMount(() => {
      if (!isBrowser)
        return;
      const triggerEl = document.getElementById(m.ids.trigger.get());
      if (isHTMLElement(triggerEl) && rootOpen.get()) {
        rootActiveTrigger.set(triggerEl);
      }
    });
    return {
      ids: m.ids,
      elements: {
        ...m.elements,
        menu,
        trigger
      },
      builders: m.builders,
      states: m.states,
      options: options2
    };
  };
  function handleCrossMenuNavigation(e) {
    if (!isBrowser)
      return;
    e.preventDefault();
    const currentTarget = e.currentTarget;
    const target = e.target;
    if (!isHTMLElement(target) || !isHTMLElement(currentTarget))
      return;
    const targetIsSubTrigger = target.hasAttribute("data-melt-menubar-menu-subtrigger");
    const isKeyDownInsideSubMenu = target.closest('[role="menu"]') !== currentTarget;
    const prevMenuKey = kbd.ARROW_LEFT;
    const isPrevKey = e.key === prevMenuKey;
    const isNextKey = !isPrevKey;
    if (isNextKey && targetIsSubTrigger)
      return;
    if (isPrevKey && isKeyDownInsideSubMenu)
      return;
    const menubarEl = document.getElementById(ids.menubar.get());
    if (!isHTMLElement(menubarEl))
      return;
    const triggers = getMenuTriggers(menubarEl);
    const currTriggerId = currentTarget.getAttribute("aria-labelledby");
    const currIndex = triggers.findIndex((trigger) => trigger.id === currTriggerId);
    let nextIndex;
    switch (e.key) {
      case kbd.ARROW_RIGHT:
        nextIndex = currIndex < triggers.length - 1 ? currIndex + 1 : 0;
        break;
      case kbd.ARROW_LEFT:
        nextIndex = currIndex > 0 ? currIndex - 1 : triggers.length - 1;
        break;
      case kbd.HOME:
        nextIndex = 0;
        break;
      case kbd.END:
        nextIndex = triggers.length - 1;
        break;
      default:
        return;
    }
    const nextFocusedTrigger = triggers[nextIndex];
    const menuId = nextFocusedTrigger.getAttribute("aria-controls");
    menuId && activeMenu.set(menuId);
  }
  function getMenuTriggers(el) {
    const menuEl = el.closest('[role="menubar"]');
    if (!isHTMLElement(menuEl))
      return [];
    return Array.from(menuEl.querySelectorAll("[data-melt-menubar-trigger]")).filter((el2) => isHTMLElement(el2));
  }
  function handleMenubarNavigation(e) {
    e.preventDefault();
    const currentFocusedItem = document.activeElement;
    const currentTarget = e.currentTarget;
    if (!isHTMLElement(currentTarget) || !isHTMLElement(currentFocusedItem))
      return;
    const menuTriggers = getMenuTriggers(currentTarget);
    if (!menuTriggers.length)
      return;
    const candidateNodes = menuTriggers.filter((item) => {
      if (item.hasAttribute("data-disabled")) {
        return false;
      }
      if (item.getAttribute("disabled") === "true") {
        return false;
      }
      return true;
    });
    const currentIndex = candidateNodes.indexOf(currentFocusedItem);
    let nextIndex;
    const $loop = loop.get();
    switch (e.key) {
      case kbd.ARROW_RIGHT:
        nextIndex = currentIndex < candidateNodes.length - 1 ? currentIndex + 1 : $loop ? 0 : currentIndex;
        break;
      case kbd.ARROW_LEFT:
        nextIndex = currentIndex > 0 ? currentIndex - 1 : $loop ? candidateNodes.length - 1 : 0;
        break;
      case kbd.HOME:
        nextIndex = 0;
        break;
      case kbd.END:
        nextIndex = candidateNodes.length - 1;
        break;
      default:
        return;
    }
    handleRovingFocus(candidateNodes[nextIndex]);
  }
  safeOnMount(() => {
    if (!isBrowser)
      return;
    const menubarEl = document.getElementById(ids.menubar.get());
    if (!menubarEl)
      return;
    const unsubEvents = executeCallbacks(addMeltEventListener(menubarEl, "keydown", (e) => {
      const target = e.target;
      const menuEl = e.currentTarget;
      if (!isHTMLElement(menuEl) || !isHTMLElement(target))
        return;
      const isTargetTrigger = target.hasAttribute("data-melt-menubar-trigger");
      if (!isTargetTrigger)
        return;
      if (MENUBAR_NAV_KEYS.includes(e.key)) {
        handleMenubarNavigation(e);
      }
    }), addEventListener(document, "keydown", (e) => {
      if (closeOnEscape.get() && e.key === kbd.ESCAPE) {
        window.clearTimeout(closeTimer.get());
        activeMenu.set("");
      }
    }));
    return () => {
      unsubEvents();
    };
  });
  const unsubs = [];
  effect([activeMenu, preventScroll], ([$activeMenu, $preventScroll]) => {
    if (!isBrowser || !$preventScroll)
      return;
    if (!$activeMenu) {
      unsubs.forEach((unsub) => unsub());
      scrollRemoved = false;
    } else if (!scrollRemoved) {
      unsubs.push(removeScroll());
      scrollRemoved = true;
    }
  });
  safeOnDestroy(() => {
    unsubs.forEach((unsub) => unsub());
  });
  return {
    ids,
    elements: {
      menubar
    },
    builders: {
      createMenu
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/pagination/helpers.js
function getPageItems({ page = 1, totalPages, siblingCount = 1 }) {
  const pageItems = [];
  const pagesToShow = /* @__PURE__ */ new Set([1, totalPages]);
  const firstItemWithSiblings = 3 + siblingCount;
  const lastItemWithSiblings = totalPages - 2 - siblingCount;
  if (firstItemWithSiblings > lastItemWithSiblings) {
    for (let p = 2; p <= totalPages - 1; p++) {
      pagesToShow.add(p);
    }
  } else if (page < firstItemWithSiblings) {
    for (let p = 2; p <= Math.min(firstItemWithSiblings, totalPages); p++) {
      pagesToShow.add(p);
    }
  } else if (page > lastItemWithSiblings) {
    for (let p = totalPages - 1; p >= Math.max(lastItemWithSiblings, 2); p--) {
      pagesToShow.add(p);
    }
  } else {
    for (let p = Math.max(page - siblingCount, 2); p <= Math.min(page + siblingCount, totalPages); p++) {
      pagesToShow.add(p);
    }
  }
  const addPage = (value) => {
    pageItems.push({ type: "page", value, key: `page-${value}` });
  };
  const addEllipsis = () => {
    pageItems.push({ type: "ellipsis", key: `ellipsis-${pageItems.length}` });
  };
  let lastNumber = 0;
  for (const page2 of Array.from(pagesToShow).sort((a, b) => a - b)) {
    if (page2 - lastNumber > 1) {
      addEllipsis();
    }
    addPage(page2);
    lastNumber = page2;
  }
  return pageItems;
}

// node_modules/@melt-ui/svelte/dist/builders/pagination/create.js
var defaults19 = {
  perPage: 1,
  siblingCount: 1,
  defaultPage: 1
};
var { name: name11, selector: selector3 } = createElHelpers("pagination");
function createPagination(props) {
  const withDefaults = { ...defaults19, ...props };
  const pageWritable = withDefaults.page ?? writable(withDefaults.defaultPage);
  const page = overridable(pageWritable, withDefaults == null ? void 0 : withDefaults.onPageChange);
  const options = toWritableStores(omit(withDefaults, "page", "onPageChange", "defaultPage"));
  const { perPage, siblingCount, count } = options;
  const totalPages = withGet.derived([count, perPage], ([$count, $perPage]) => {
    return Math.ceil($count / $perPage);
  });
  const range = derived([page, perPage, count], ([$page, $perPage, $count]) => {
    const start = ($page - 1) * $perPage;
    const end = Math.min(start + $perPage, $count);
    return { start, end };
  });
  const root = makeElement(name11(), {
    returned: () => ({
      "data-scope": "pagination"
    })
  });
  const pages = derived([page, totalPages, siblingCount], ([$page, $totalPages, $siblingCount]) => {
    return getPageItems({ page: $page, totalPages: $totalPages, siblingCount: $siblingCount });
  });
  const keydown = (e) => {
    const thisEl = e.target;
    if (!isHTMLElement(thisEl))
      return;
    const rootEl = thisEl.closest('[data-scope="pagination"]');
    if (!isHTMLElement(rootEl))
      return;
    const triggers = Array.from(rootEl.querySelectorAll(selector3("page"))).filter((el) => isHTMLElement(el));
    const prevButton2 = rootEl.querySelector(selector3("prev"));
    const nextButton2 = rootEl.querySelector(selector3("next"));
    if (isHTMLElement(prevButton2)) {
      triggers.unshift(prevButton2);
    }
    if (isHTMLElement(nextButton2)) {
      triggers.push(nextButton2);
    }
    const index = triggers.indexOf(thisEl);
    if (e.key === kbd.ARROW_LEFT && index !== 0) {
      e.preventDefault();
      triggers[index - 1].focus();
    } else if (e.key === kbd.ARROW_RIGHT && index !== triggers.length - 1) {
      e.preventDefault();
      triggers[index + 1].focus();
    } else if (e.key === kbd.HOME) {
      e.preventDefault();
      triggers[0].focus();
    } else if (e.key === kbd.END) {
      e.preventDefault();
      triggers[triggers.length - 1].focus();
    }
  };
  const pageTrigger = makeElement(name11("page"), {
    stores: page,
    returned: ($page) => {
      return (pageItem) => {
        return {
          "aria-label": `Page ${pageItem.value}`,
          "data-value": pageItem.value,
          "data-selected": pageItem.value === $page ? "" : void 0
        };
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        const value = node.dataset.value;
        if (!value || Number.isNaN(+value))
          return;
        page.set(Number(value));
      }), addMeltEventListener(node, "keydown", keydown));
      return {
        destroy: unsub
      };
    }
  });
  const prevButton = makeElement(name11("prev"), {
    stores: page,
    returned: ($page) => {
      return {
        "aria-label": "Previous",
        disabled: $page <= 1
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        page.update((p) => Math.max(p - 1, 1));
      }), addMeltEventListener(node, "keydown", keydown));
      return {
        destroy: unsub
      };
    }
  });
  const nextButton = makeElement(name11("next"), {
    stores: [page, totalPages],
    returned: ([$page, $totalPages]) => {
      return {
        "aria-label": "Next",
        disabled: $page >= $totalPages
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        const $totalPages = totalPages.get();
        page.update((p) => Math.min(p + 1, $totalPages));
      }), addMeltEventListener(node, "keydown", keydown));
      return {
        destroy: unsub
      };
    }
  });
  return {
    elements: {
      root,
      pageTrigger,
      prevButton,
      nextButton
    },
    states: {
      range: readonly(range),
      page,
      pages: readonly(pages),
      totalPages: readonly(totalPages)
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/pin-input/create.js
var prefix2 = "pin-input";
var { name: name12, selector: selector4 } = createElHelpers(prefix2);
var getInputs = (node) => {
  const rootEl = node.closest(selector4());
  if (!isHTMLElement(rootEl)) {
    return { inputs: null, el: node, elIndex: -1 };
  }
  const inputs = Array.from(rootEl.querySelectorAll(selector4("input"))).filter((input) => isHTMLInputElement(input));
  return {
    elIndex: inputs.indexOf(node),
    inputs
  };
};
var defaults20 = {
  placeholder: "○",
  disabled: false,
  type: "text",
  name: void 0,
  defaultValue: []
};
var pinInputIdParts = ["root"];
function createPinInput(props) {
  const withDefaults = { ...defaults20, ...props };
  const options = toWritableStores(omit(withDefaults, "value", "ids"));
  const { placeholder, disabled, type, name: nameStore } = options;
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults == null ? void 0 : withDefaults.onValueChange);
  const valueStr = derived(value, (v) => v.join(""));
  const ids = toWritableStores({ ...generateIds(pinInputIdParts), ...withDefaults.ids });
  const root = makeElement(name12(), {
    stores: [value, ids.root],
    returned: ([$value, $rootId]) => {
      return {
        id: $rootId,
        "data-complete": $value.length && $value.every((v) => v.length > 0) ? "" : void 0
      };
    }
  });
  let index = 0;
  const getTotalItems = () => {
    if (!isBrowser)
      return Infinity;
    const rootEl = document.getElementById(ids.root.get());
    if (!rootEl)
      return Infinity;
    const inputs = Array.from(rootEl.querySelectorAll(selector4("input")));
    return inputs.length;
  };
  const input = makeElement(name12("input"), {
    stores: [value, placeholder, disabled, type],
    returned: ([$value, $placeholder, $disabled, $type]) => {
      return () => {
        const totalItems = getTotalItems();
        const currIndex = index % totalItems;
        index = (index + 1) % totalItems;
        const currValue = $value[currIndex] ?? "";
        return {
          "data-complete": $value.length && $value.every((v) => v.length > 0) ? "" : void 0,
          placeholder: $placeholder,
          disabled: disabledAttr($disabled),
          type: $type,
          value: currValue
        };
      };
    },
    action: (node) => {
      const { elIndex } = getInputs(node);
      value.update((v) => {
        v[elIndex] = node.value;
        return v;
      });
      const unsub = executeCallbacks(addMeltEventListener(node, "keydown", (e) => {
        const { inputs, elIndex: elIndex2 } = getInputs(node);
        if (!inputs)
          return;
        if (e.key === "Backspace") {
          e.preventDefault();
          if (node.value) {
            node.value = "";
            tick().then(() => node.placeholder = "");
            value.set(inputs.map((input2) => input2.value.slice(-1) ?? void 0));
          } else {
            const prevEl = prev(inputs, elIndex2, false);
            prevEl.focus();
            prevEl.value = "";
            tick().then(() => prevEl.placeholder = "");
            value.set(inputs.map((input2) => input2.value.slice(-1) ?? void 0));
          }
        }
        if (e.key === "Delete") {
          e.preventDefault();
          node.value = "";
          tick().then(() => node.placeholder = "");
          value.set(inputs.map((input2) => input2.value.slice(-1) ?? void 0));
        }
        if (e.key === "ArrowLeft") {
          e.preventDefault();
          const prevEl = prev(inputs, elIndex2, false);
          prevEl.focus();
        }
        if (e.key === "ArrowRight") {
          e.preventDefault();
          const nextEl = next(inputs, elIndex2, false);
          nextEl.focus();
        }
        if (e.key === "Home") {
          e.preventDefault();
          inputs[0].focus();
        }
        if (e.key === "End") {
          e.preventDefault();
          last(inputs).focus();
        }
      }), addMeltEventListener(node, "input", (e) => {
        const { inputs, elIndex: elIndex2 } = getInputs(node);
        if (!inputs)
          return;
        const getInputted = (el) => {
          const $value = value.get();
          const prevElValue = $value[elIndex2];
          const selectionStart = el.selectionStart ?? 1;
          if (!prevElValue)
            return el.value;
          return selectionStart > 1 ? el.value.slice(1) : el.value.slice(0, Math.max(el.value.length - 2, 1));
        };
        const inputted = getInputted(node);
        const inputEvent = e;
        if (inputEvent.inputType === "insertFromPaste") {
          return;
        }
        node.value = inputted.slice(-1);
        if (node.value.length !== 0) {
          const nextEl = next(inputs, elIndex2, false);
          nextEl.focus();
        }
        value.set(inputs.map((input2) => input2.value.slice(-1) ?? void 0));
      }), addMeltEventListener(node, "paste", (e) => {
        var _a;
        e.preventDefault();
        const { inputs, elIndex: elIndex2 } = getInputs(node);
        if (!inputs)
          return;
        const inputEvent = e;
        const clipboardData = inputEvent.clipboardData;
        if (!clipboardData)
          return;
        const pasted = clipboardData.getData("text");
        const initialIndex = pasted.length >= inputs.length ? 0 : elIndex2;
        const lastIndex = Math.min(initialIndex + pasted.length, inputs.length);
        for (let i = initialIndex; i < lastIndex; i++) {
          const input2 = inputs[i];
          input2.value = pasted[i - initialIndex];
          input2.focus();
        }
        (_a = inputs[lastIndex]) == null ? void 0 : _a.focus();
        value.set(inputs.map((input2) => input2.value.slice(-1) ?? void 0));
      }), addMeltEventListener(node, "change", () => {
        const { inputs } = getInputs(node);
        if (!inputs)
          return;
        value.set(inputs.map((input2) => input2.value.slice(-1) ?? void 0));
      }), addMeltEventListener(node, "focus", () => {
        node.setSelectionRange(1, 1);
        node.placeholder = "";
        tick().then(() => {
          node.placeholder = "";
        });
      }), addMeltEventListener(node, "blur", () => {
        node.placeholder = placeholder.get();
      }));
      return {
        destroy() {
          unsub();
        }
      };
    }
  });
  const hiddenInput = createHiddenInput({
    value: valueStr,
    disabled,
    name: nameStore,
    prefix: prefix2
  });
  const clear = () => {
    value.update((v) => {
      v.forEach((_, i) => v[i] = "");
      return v;
    });
  };
  return {
    ids,
    elements: {
      root,
      input,
      hiddenInput
    },
    states: {
      value,
      valueStr: readonly(valueStr)
    },
    helpers: {
      clear
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/popover/create.js
var defaults21 = {
  positioning: {
    placement: "bottom"
  },
  arrowSize: 8,
  defaultOpen: false,
  disableFocusTrap: false,
  closeOnEscape: true,
  preventScroll: false,
  onOpenChange: void 0,
  closeOnOutsideClick: true,
  portal: void 0,
  forceVisible: false,
  openFocus: void 0,
  closeFocus: void 0,
  onOutsideClick: void 0
};
var { name: name13 } = createElHelpers("popover");
var popoverIdParts = ["trigger", "content"];
function createPopover(args) {
  const withDefaults = { ...defaults21, ...args };
  const options = toWritableStores(omit(withDefaults, "open", "ids"));
  const { positioning, arrowSize, disableFocusTrap, preventScroll, closeOnEscape, closeOnOutsideClick, portal, forceVisible, openFocus, closeFocus, onOutsideClick } = options;
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const open = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const activeTrigger = writable(null);
  const ids = toWritableStores({ ...generateIds(popoverIdParts), ...withDefaults.ids });
  safeOnMount(() => {
    activeTrigger.set(document.getElementById(ids.trigger.get()));
  });
  function handleClose() {
    open.set(false);
    const triggerEl = document.getElementById(ids.trigger.get());
    handleFocus({ prop: closeFocus.get(), defaultEl: triggerEl });
  }
  const isVisible = derivedVisible({ open, activeTrigger, forceVisible });
  const content = makeElement(name13("content"), {
    stores: [isVisible, portal, ids.content],
    returned: ([$isVisible, $portal, $contentId]) => {
      return {
        hidden: $isVisible && isBrowser ? void 0 : true,
        tabindex: -1,
        style: styleToString({
          display: $isVisible ? void 0 : "none"
        }),
        id: $contentId,
        "data-state": $isVisible ? "open" : "closed",
        "data-portal": portalAttr($portal)
      };
    },
    action: (node) => {
      let unsubPopper = noop2;
      const unsubDerived = effect([
        isVisible,
        activeTrigger,
        positioning,
        disableFocusTrap,
        closeOnEscape,
        closeOnOutsideClick,
        portal
      ], ([$isVisible, $activeTrigger, $positioning, $disableFocusTrap, $closeOnEscape, $closeOnOutsideClick, $portal]) => {
        unsubPopper();
        if (!$isVisible || !$activeTrigger)
          return;
        tick().then(() => {
          const popper = usePopper(node, {
            anchorElement: $activeTrigger,
            open,
            options: {
              floating: $positioning,
              focusTrap: $disableFocusTrap ? null : {
                returnFocusOnDeactivate: false,
                clickOutsideDeactivates: true,
                escapeDeactivates: true
              },
              modal: {
                shouldCloseOnInteractOutside,
                onClose: handleClose,
                open: $isVisible,
                closeOnInteractOutside: $closeOnOutsideClick
              },
              escapeKeydown: $closeOnEscape ? {
                handler: () => {
                  handleClose();
                }
              } : null,
              portal: getPortalDestination(node, $portal)
            }
          });
          if (popper && popper.destroy) {
            unsubPopper = popper.destroy;
          }
        });
      });
      return {
        destroy() {
          unsubDerived();
          unsubPopper();
        }
      };
    }
  });
  function toggleOpen(triggerEl) {
    open.update((prev2) => {
      return !prev2;
    });
    if (triggerEl) {
      activeTrigger.set(triggerEl);
    }
  }
  function shouldCloseOnInteractOutside(e) {
    var _a;
    (_a = onOutsideClick.get()) == null ? void 0 : _a(e);
    if (e.defaultPrevented)
      return false;
    const target = e.target;
    const triggerEl = document.getElementById(ids.trigger.get());
    if (triggerEl && isElement(target)) {
      if (target === triggerEl || triggerEl.contains(target))
        return false;
    }
    return true;
  }
  const trigger = makeElement(name13("trigger"), {
    stores: [isVisible, ids.content, ids.trigger],
    returned: ([$isVisible, $contentId, $triggerId]) => {
      return {
        role: "button",
        "aria-haspopup": "dialog",
        "aria-expanded": $isVisible ? "true" : "false",
        "data-state": stateAttr2($isVisible),
        "aria-controls": $contentId,
        id: $triggerId
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        toggleOpen(node);
      }), addMeltEventListener(node, "keydown", (e) => {
        if (e.key !== kbd.ENTER && e.key !== kbd.SPACE)
          return;
        e.preventDefault();
        toggleOpen(node);
      }));
      return {
        destroy: unsub
      };
    }
  });
  const overlay = makeElement(name13("overlay"), {
    stores: [isVisible],
    returned: ([$isVisible]) => {
      return {
        hidden: $isVisible ? void 0 : true,
        tabindex: -1,
        style: styleToString({
          display: $isVisible ? void 0 : "none"
        }),
        "aria-hidden": "true",
        "data-state": stateAttr2($isVisible)
      };
    },
    action: (node) => {
      let unsubEscapeKeydown = noop2;
      if (closeOnEscape.get()) {
        const escapeKeydown = useEscapeKeydown(node, {
          handler: () => {
            handleClose();
          }
        });
        if (escapeKeydown && escapeKeydown.destroy) {
          unsubEscapeKeydown = escapeKeydown.destroy;
        }
      }
      const unsubPortal = effect([portal], ([$portal]) => {
        if ($portal === null)
          return noop2;
        const portalDestination = getPortalDestination(node, $portal);
        if (portalDestination === null)
          return noop2;
        const portalAction = usePortal(node, portalDestination);
        if (portalAction && portalAction.destroy) {
          return portalAction.destroy;
        } else {
          return noop2;
        }
      });
      return {
        destroy() {
          unsubEscapeKeydown();
          unsubPortal();
        }
      };
    }
  });
  const arrow3 = makeElement(name13("arrow"), {
    stores: arrowSize,
    returned: ($arrowSize) => ({
      "data-arrow": true,
      style: styleToString({
        position: "absolute",
        width: `var(--arrow-size, ${$arrowSize}px)`,
        height: `var(--arrow-size, ${$arrowSize}px)`
      })
    })
  });
  const close = makeElement(name13("close"), {
    returned: () => ({
      type: "button"
    }),
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", (e) => {
        if (e.defaultPrevented)
          return;
        handleClose();
      }), addMeltEventListener(node, "keydown", (e) => {
        if (e.defaultPrevented)
          return;
        if (e.key !== kbd.ENTER && e.key !== kbd.SPACE)
          return;
        e.preventDefault();
        toggleOpen();
      }));
      return {
        destroy: unsub
      };
    }
  });
  effect([open, activeTrigger, preventScroll], ([$open, $activeTrigger, $preventScroll]) => {
    if (!isBrowser)
      return;
    const unsubs = [];
    if ($open) {
      if (!$activeTrigger) {
        tick().then(() => {
          const triggerEl2 = document.getElementById(ids.trigger.get());
          if (!isHTMLElement(triggerEl2))
            return;
          activeTrigger.set(triggerEl2);
        });
      }
      if ($preventScroll) {
        unsubs.push(removeScroll());
      }
      const triggerEl = $activeTrigger ?? document.getElementById(ids.trigger.get());
      handleFocus({ prop: openFocus.get(), defaultEl: triggerEl });
    }
    return () => {
      unsubs.forEach((unsub) => unsub());
    };
  });
  return {
    ids,
    elements: {
      trigger,
      content,
      arrow: arrow3,
      close,
      overlay
    },
    states: {
      open
    },
    options
  };
}
function stateAttr2(open) {
  return open ? "open" : "closed";
}

// node_modules/@melt-ui/svelte/dist/builders/progress/create.js
var defaults22 = {
  defaultValue: 0,
  max: 100
};
var { name: name14 } = createElHelpers("progress");
var createProgress = (props) => {
  const withDefaults = { ...defaults22, ...props };
  const options = toWritableStores(omit(withDefaults, "value"));
  const { max: max2 } = options;
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults == null ? void 0 : withDefaults.onValueChange);
  const root = makeElement(name14(), {
    stores: [value, max2],
    returned: ([$value, $max]) => {
      return {
        value: $value,
        max: $max,
        role: "meter",
        "aria-valuemin": 0,
        "aria-valuemax": $max,
        "aria-valuenow": $value,
        "data-value": $value,
        "data-state": $value === null ? "indeterminate" : $value === $max ? "complete" : "loading",
        "data-max": $max
      };
    }
  });
  return {
    elements: {
      root
    },
    states: {
      value
    },
    options
  };
};

// node_modules/@melt-ui/svelte/dist/builders/radio-group/create.js
var defaults23 = {
  orientation: "vertical",
  loop: true,
  disabled: false,
  required: false,
  defaultValue: void 0
};
var prefix3 = "radio-group";
var { name: name15, selector: selector5 } = createElHelpers(prefix3);
function createRadioGroup(props) {
  const withDefaults = { ...defaults23, ...props };
  const options = toWritableStores(omit(withDefaults, "value"));
  const { disabled, required, loop, orientation } = options;
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults == null ? void 0 : withDefaults.onValueChange);
  const focusedHistory = {
    prev: null,
    curr: null
  };
  safeOnMount(() => {
    return addEventListener(document, "focus", (e) => {
      const focusedItem = e.target;
      if (!isHTMLElement(focusedItem))
        return;
      focusedHistory.prev = focusedHistory.curr;
      focusedHistory.curr = focusedItem;
    });
  });
  let hasActiveTabIndex = false;
  effect(value, ($value) => {
    if ($value === void 0) {
      hasActiveTabIndex = false;
    } else {
      hasActiveTabIndex = true;
    }
  });
  const selectItem = (item2) => {
    const disabled2 = item2.dataset.disabled === "true";
    const itemValue = item2.dataset.value;
    if (disabled2 || itemValue === void 0)
      return;
    value.set(itemValue);
  };
  const root = makeElement(name15(), {
    stores: [required, orientation],
    returned: ([$required, $orientation]) => {
      return {
        role: "radiogroup",
        "aria-required": $required,
        "data-orientation": $orientation
      };
    }
  });
  const item = makeElement(name15("item"), {
    stores: [value, orientation, disabled],
    returned: ([$value, $orientation, $disabled]) => {
      return (props2) => {
        const itemValue = typeof props2 === "string" ? props2 : props2.value;
        const argDisabled = typeof props2 === "string" ? false : !!props2.disabled;
        const disabled2 = $disabled || argDisabled;
        const checked = $value === itemValue;
        const tabindex = !hasActiveTabIndex ? 0 : checked ? 0 : -1;
        hasActiveTabIndex = true;
        return {
          disabled: disabled2,
          "data-value": itemValue,
          "data-orientation": $orientation,
          "data-disabled": disabledAttr(disabled2),
          "data-state": checked ? "checked" : "unchecked",
          "aria-checked": checked,
          type: "button",
          role: "radio",
          tabindex
        };
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        selectItem(node);
      }), addMeltEventListener(node, "keydown", (e) => {
        const el = e.currentTarget;
        if (!isHTMLElement(el))
          return;
        const root2 = el.closest(selector5());
        if (!isHTMLElement(root2))
          return;
        const items = Array.from(root2.querySelectorAll(selector5("item"))).filter((el2) => isHTMLElement(el2) && !el2.hasAttribute("data-disabled"));
        const currentIndex = items.indexOf(el);
        const dir = getElemDirection(root2);
        const { nextKey, prevKey } = getDirectionalKeys(dir, orientation.get());
        const $loop = loop.get();
        let itemToFocus = null;
        if (e.key === nextKey) {
          e.preventDefault();
          const nextIndex = currentIndex + 1;
          if (nextIndex >= items.length && $loop) {
            itemToFocus = items[0];
          } else {
            itemToFocus = items[nextIndex];
          }
        } else if (e.key === prevKey) {
          e.preventDefault();
          const prevIndex = currentIndex - 1;
          if (prevIndex < 0 && $loop) {
            itemToFocus = items[items.length - 1];
          } else {
            itemToFocus = items[prevIndex];
          }
        } else if (e.key === kbd.HOME) {
          e.preventDefault();
          itemToFocus = items[0];
        } else if (e.key === kbd.END) {
          e.preventDefault();
          itemToFocus = items[items.length - 1];
        }
        if (itemToFocus) {
          itemToFocus.focus();
          selectItem(itemToFocus);
        }
      }));
      return {
        destroy: unsub
      };
    }
  });
  const hiddenInput = createHiddenInput({
    value,
    disabled,
    required
  });
  const isChecked = derived(value, ($value) => {
    return (itemValue) => {
      return $value === itemValue;
    };
  });
  return {
    elements: {
      root,
      item,
      hiddenInput
    },
    states: {
      value
    },
    helpers: {
      isChecked
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/range-calendar/create.js
var defaults24 = {
  isDateDisabled: void 0,
  isDateUnavailable: void 0,
  value: void 0,
  defaultValue: {
    start: void 0,
    end: void 0
  },
  preventDeselect: false,
  numberOfMonths: 1,
  pagedNavigation: false,
  weekStartsOn: 0,
  fixedWeeks: false,
  calendarLabel: "Event Date",
  locale: "en",
  minValue: void 0,
  maxValue: void 0,
  disabled: false,
  readonly: false,
  weekdayFormat: "narrow"
};
var { name: name16 } = createElHelpers("calendar");
var rangeCalendarIdParts = ["calendar", "accessibleHeading"];
function createRangeCalendar(props) {
  var _a, _b, _c;
  const withDefaults = { ...defaults24, ...props };
  const options = toWritableStores({
    ...omit(withDefaults, "value", "placeholder")
  });
  const { preventDeselect, numberOfMonths, pagedNavigation, weekStartsOn, fixedWeeks, calendarLabel, locale, minValue, maxValue, disabled, readonly: readonly2, weekdayFormat } = options;
  const ids = toWritableStores({ ...generateIds(rangeCalendarIdParts), ...withDefaults.ids });
  const defaultDate = getDefaultDate({
    defaultValue: (_a = withDefaults.defaultValue) == null ? void 0 : _a.start,
    defaultPlaceholder: withDefaults.defaultPlaceholder
  });
  const formatter = createFormatter(locale.get());
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults.onValueChange);
  if (!value.get()) {
    value.set(withDefaults.defaultValue);
  }
  const startValue = withGet(writable(value.get().start ?? ((_b = withDefaults.defaultValue) == null ? void 0 : _b.start)));
  const endValue = withGet(writable(value.get().end ?? ((_c = withDefaults.defaultValue) == null ? void 0 : _c.end)));
  const placeholderWritable = withDefaults.placeholder ?? writable(withDefaults.defaultPlaceholder ?? defaultDate);
  const placeholder = dateStore(overridable(placeholderWritable, withDefaults.onPlaceholderChange), withDefaults.defaultPlaceholder ?? defaultDate);
  const focusedValue = withGet(writable(null));
  const lastPressedDateValue = withGet(writable(null));
  const months = withGet(writable(createMonths({
    dateObj: placeholder.get(),
    weekStartsOn: withDefaults.weekStartsOn,
    locale: withDefaults.locale,
    fixedWeeks: withDefaults.fixedWeeks,
    numberOfMonths: withDefaults.numberOfMonths
  })));
  const visibleMonths = withGet(derived([months], ([$months]) => {
    return $months.map((month) => {
      return month.value;
    });
  }));
  const isOutsideVisibleMonths = withGet(derived([visibleMonths], ([$visibleMonths]) => {
    return (date) => {
      return !$visibleMonths.some((month) => $14e0f24ef4ac5c92$export$a18c89cbd24170ff(date, month));
    };
  }));
  const isDateDisabled = withGet(derived([options.isDateDisabled, minValue, maxValue], ([$isDateDisabled, $minValue, $maxValue]) => {
    return (date) => {
      if ($isDateDisabled == null ? void 0 : $isDateDisabled(date))
        return true;
      if ($minValue && isBefore(date, $minValue))
        return true;
      if ($maxValue && isAfter(date, $maxValue))
        return true;
      return false;
    };
  }));
  const isDateUnavailable = withGet(derived([options.isDateUnavailable], ([$isDateUnavailable]) => {
    return (date) => {
      if ($isDateUnavailable == null ? void 0 : $isDateUnavailable(date))
        return true;
      return false;
    };
  }));
  const isStartInvalid = derived([startValue, isDateUnavailable, isDateDisabled], ([$startValue, $isDateUnavailable, $isDateDisabled]) => {
    if (!$startValue)
      return false;
    return $isDateUnavailable($startValue) || $isDateDisabled($startValue);
  });
  const isEndInvalid = derived([endValue, isDateUnavailable, isDateDisabled], ([$endValue, $isDateUnavailable, $isDateDisabled]) => {
    if (!$endValue)
      return false;
    return $isDateUnavailable($endValue) || $isDateDisabled($endValue);
  });
  const isInvalid = derived([startValue, endValue, isEndInvalid, isStartInvalid], ([$startValue, $endValue, $isEndInvalid, $isStartInvalid]) => {
    if ($isStartInvalid || $isEndInvalid) {
      return true;
    }
    if ($endValue && $startValue && isBefore($endValue, $startValue)) {
      return true;
    }
    return false;
  });
  const isNextButtonDisabled = withGet.derived([months, maxValue, disabled], ([$months, $maxValue, $disabled]) => {
    if (!$maxValue || !$months.length)
      return false;
    if ($disabled)
      return true;
    const lastMonthInView = $months[$months.length - 1].value;
    const firstMonthOfNextPage = lastMonthInView.add({ months: 1 }).set({ day: 1 });
    return isAfter(firstMonthOfNextPage, $maxValue);
  });
  const isPrevButtonDisabled = withGet.derived([months, minValue, disabled], ([$months, $minValue, $disabled]) => {
    if (!$minValue || !$months.length)
      return false;
    if ($disabled)
      return true;
    const firstMonthInView = $months[0].value;
    const lastMonthOfPrevPage = firstMonthInView.subtract({ months: 1 }).set({ day: 35 });
    return isBefore(lastMonthOfPrevPage, $minValue);
  });
  let announcer = getAnnouncer();
  const headingValue = withGet.derived([months, locale], ([$months, $locale]) => {
    if (!$months.length)
      return "";
    if ($locale !== formatter.getLocale()) {
      formatter.setLocale($locale);
    }
    if ($months.length === 1) {
      const month = toDate($months[0].value);
      return `${formatter.fullMonthAndYear(month)}`;
    }
    const startMonth = toDate($months[0].value);
    const endMonth = toDate($months[$months.length - 1].value);
    const startMonthName = formatter.fullMonth(startMonth);
    const endMonthName = formatter.fullMonth(endMonth);
    const startMonthYear = formatter.fullYear(startMonth);
    const endMonthYear = formatter.fullYear(endMonth);
    const content = startMonthYear === endMonthYear ? `${startMonthName} - ${endMonthName} ${endMonthYear}` : `${startMonthName} ${startMonthYear} - ${endMonthName} ${endMonthYear}`;
    return content;
  });
  const fullCalendarLabel = withGet.derived([headingValue, calendarLabel], ([$headingValue, $calendarLabel]) => {
    return `${$calendarLabel}, ${$headingValue}`;
  });
  const calendar = makeElement(name16(), {
    stores: [fullCalendarLabel, isInvalid, ids.calendar, disabled, readonly2],
    returned: ([$fullCalendarLabel, $isInvalid, $calendarId, $disabled, $readonly]) => {
      return {
        id: $calendarId,
        role: "application",
        "aria-label": $fullCalendarLabel,
        "data-invalid": $isInvalid ? "" : void 0,
        "data-disabled": $disabled ? "" : void 0,
        "data-readonly": $readonly ? "" : void 0
      };
    },
    action: (node) => {
      createAccessibleHeading(node, fullCalendarLabel.get());
      announcer = getAnnouncer();
      const unsubKb = addMeltEventListener(node, "keydown", handleCalendarKeydown);
      return {
        destroy() {
          unsubKb();
        }
      };
    }
  });
  const heading = makeElement(name16("heading"), {
    stores: [disabled],
    returned: ([$disabled]) => {
      return {
        "aria-hidden": true,
        "data-disabled": $disabled ? "" : void 0
      };
    }
  });
  const grid = makeElement(name16("grid"), {
    stores: [readonly2, disabled],
    returned: ([$readonly, $disabled]) => ({
      tabindex: -1,
      role: "grid",
      "aria-readonly": $readonly ? "true" : void 0,
      "aria-disabled": $disabled ? "true" : void 0,
      "data-readonly": $readonly ? "" : void 0,
      "data-disabled": $disabled ? "" : void 0
    })
  });
  const prevButton = makeElement(name16("prevButton"), {
    stores: [isPrevButtonDisabled],
    returned: ([$isPrevButtonDisabled]) => {
      const disabled2 = $isPrevButtonDisabled;
      return {
        role: "button",
        type: "button",
        "aria-label": "Previous",
        "aria-disabled": disabled2 ? "true" : void 0,
        disabled: disabled2 ? true : void 0,
        "data-disabled": disabled2 ? "" : void 0
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        prevPage();
      }));
      return {
        destroy: unsub
      };
    }
  });
  const nextButton = makeElement(name16("nextButton"), {
    stores: [isNextButtonDisabled],
    returned: ([$isNextButtonDisabled]) => {
      const disabled2 = $isNextButtonDisabled;
      return {
        role: "button",
        type: "button",
        "aria-label": "Next",
        "aria-disabled": disabled2 ? "true" : void 0,
        disabled: disabled2 ? true : void 0,
        "data-disabled": disabled2 ? "" : void 0
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        nextPage();
      }));
      return {
        destroy: unsub
      };
    }
  });
  const isSelectionStart = derived([startValue], ([$startValue]) => {
    return (date) => {
      if (!$startValue)
        return false;
      return $14e0f24ef4ac5c92$export$ea39ec197993aef0($startValue, date);
    };
  });
  const isSelectionEnd = derived([endValue], ([$endValue]) => {
    return (date) => {
      if (!$endValue)
        return false;
      return $14e0f24ef4ac5c92$export$ea39ec197993aef0($endValue, date);
    };
  });
  const isSelected = derived([startValue, endValue], ([$startValue, $endValue]) => {
    return (date) => {
      if ($startValue && $14e0f24ef4ac5c92$export$ea39ec197993aef0($startValue, date))
        return true;
      if ($endValue && $14e0f24ef4ac5c92$export$ea39ec197993aef0($endValue, date))
        return true;
      if ($endValue && $startValue) {
        return isBetweenInclusive(date, $startValue, $endValue);
      }
      return false;
    };
  });
  const highlightedRange = withGet.derived([startValue, endValue, focusedValue, isDateDisabled, isDateUnavailable], ([$startValue, $endValue, $focusedValue, $isDateDisabled, $isDateUnavailable]) => {
    if ($startValue && $endValue)
      return null;
    if (!$startValue || !$focusedValue)
      return null;
    const isStartBeforeFocused = isBefore($startValue, $focusedValue);
    const start = isStartBeforeFocused ? $startValue : $focusedValue;
    const end = isStartBeforeFocused ? $focusedValue : $startValue;
    if ($14e0f24ef4ac5c92$export$ea39ec197993aef0(start.add({ days: 1 }), end)) {
      return {
        start,
        end
      };
    }
    const isValid = areAllDaysBetweenValid(start, end, $isDateUnavailable, $isDateDisabled);
    if (isValid) {
      return {
        start,
        end
      };
    }
    return null;
  });
  const cell = makeElement(name16("cell"), {
    stores: [
      isSelected,
      isSelectionEnd,
      isSelectionStart,
      highlightedRange,
      isDateDisabled,
      isDateUnavailable,
      placeholder,
      isOutsideVisibleMonths
    ],
    returned: ([$isSelected, $isSelectionEnd, $isSelectionStart, $highlightedRange, $isDateDisabled, $isDateUnavailable, $placeholder, $isOutsideVisibleMonths]) => {
      return (cellValue, monthValue) => {
        const cellDate = toDate(cellValue);
        const isDisabled = $isDateDisabled(cellValue);
        const isUnavailable = $isDateUnavailable(cellValue);
        const isDateToday = $14e0f24ef4ac5c92$export$629b0a497aa65267(cellValue, $14e0f24ef4ac5c92$export$aa8b41735afcabd2());
        const isOutsideMonth = !$14e0f24ef4ac5c92$export$a18c89cbd24170ff(cellValue, monthValue);
        const isFocusedDate = $14e0f24ef4ac5c92$export$ea39ec197993aef0(cellValue, $placeholder);
        const isOutsideVisibleMonths2 = $isOutsideVisibleMonths(cellValue);
        const isSelectedDate = $isSelected(cellValue);
        const isSelectionStart2 = $isSelectionStart(cellValue);
        const isSelectionEnd2 = $isSelectionEnd(cellValue);
        const isHighlighted = $highlightedRange ? isBetweenInclusive(cellValue, $highlightedRange.start, $highlightedRange.end) : false;
        const labelText = formatter.custom(cellDate, {
          weekday: "long",
          month: "long",
          day: "numeric",
          year: "numeric"
        });
        return {
          role: "button",
          "aria-label": labelText,
          "aria-selected": isSelectedDate ? true : void 0,
          "aria-disabled": isOutsideMonth || isDisabled || isUnavailable ? true : void 0,
          "data-selected": isSelectedDate ? true : void 0,
          "data-selection-start": isSelectionStart2 ? true : void 0,
          "data-selection-end": isSelectionEnd2 ? true : void 0,
          "data-value": cellValue.toString(),
          "data-disabled": isDisabled || isOutsideMonth ? "" : void 0,
          "data-unavailable": isUnavailable ? "" : void 0,
          "data-today": isDateToday ? "" : void 0,
          "data-outside-month": isOutsideMonth ? "" : void 0,
          "data-outside-visible-months": isOutsideVisibleMonths2 ? "" : void 0,
          "data-focused": isFocusedDate ? "" : void 0,
          "data-highlighted": isHighlighted ? "" : void 0,
          tabindex: isFocusedDate ? 0 : isOutsideMonth || isDisabled ? void 0 : -1
        };
      };
    },
    action: (node) => {
      const getElArgs = () => {
        const value2 = node.getAttribute("data-value");
        const label = node.getAttribute("data-label");
        const disabled2 = node.hasAttribute("data-disabled");
        return {
          value: value2,
          label: label ?? node.textContent ?? null,
          disabled: disabled2 ? true : false
        };
      };
      const unsub = executeCallbacks(addMeltEventListener(node, "click", (e) => {
        const args = getElArgs();
        if (args.disabled)
          return;
        if (!args.value)
          return;
        handleCellClick(e, parseStringToDateValue(args.value, placeholder.get()));
      }), addMeltEventListener(node, "mouseenter", () => {
        const args = getElArgs();
        if (args.disabled)
          return;
        if (!args.value)
          return;
        focusedValue.set(parseStringToDateValue(args.value, placeholder.get()));
      }), addMeltEventListener(node, "focusin", () => {
        const args = getElArgs();
        if (args.disabled)
          return;
        if (!args.value)
          return;
        focusedValue.set(parseStringToDateValue(args.value, placeholder.get()));
      }));
      return {
        destroy: unsub
      };
    }
  });
  effect([locale], ([$locale]) => {
    if (formatter.getLocale() === $locale)
      return;
    formatter.setLocale($locale);
  });
  effect([placeholder], ([$placeholder]) => {
    if (!isBrowser || !$placeholder)
      return;
    const $visibleMonths = visibleMonths.get();
    if ($visibleMonths.some((month) => $14e0f24ef4ac5c92$export$a18c89cbd24170ff(month, $placeholder))) {
      return;
    }
    const $weekStartsOn = weekStartsOn.get();
    const $locale = locale.get();
    const $fixedWeeks = fixedWeeks.get();
    const $numberOfMonths = numberOfMonths.get();
    const defaultMonthProps = {
      weekStartsOn: $weekStartsOn,
      locale: $locale,
      fixedWeeks: $fixedWeeks,
      numberOfMonths: $numberOfMonths
    };
    months.set(createMonths({
      ...defaultMonthProps,
      dateObj: $placeholder
    }));
  });
  effect([weekStartsOn, locale, fixedWeeks, numberOfMonths], ([$weekStartsOn, $locale, $fixedWeeks, $numberOfMonths]) => {
    const $placeholder = placeholder.get();
    if (!isBrowser || !$placeholder)
      return;
    const defaultMonthProps = {
      weekStartsOn: $weekStartsOn,
      locale: $locale,
      fixedWeeks: $fixedWeeks,
      numberOfMonths: $numberOfMonths
    };
    months.set(createMonths({
      ...defaultMonthProps,
      dateObj: $placeholder
    }));
  });
  effect([fullCalendarLabel], ([$fullCalendarLabel]) => {
    if (!isBrowser)
      return;
    const node = document.getElementById(ids.accessibleHeading.get());
    if (!isHTMLElement(node))
      return;
    node.textContent = $fullCalendarLabel;
  });
  effect([startValue], ([$startValue]) => {
    if ($startValue && placeholder.get() !== $startValue) {
      placeholder.set($startValue);
    }
  });
  const weekdays = derived([months, weekdayFormat, locale], ([$months, $weekdayFormat, _]) => {
    if (!$months.length)
      return [];
    return $months[0].weeks[0].map((date) => {
      return formatter.dayOfWeek(toDate(date), $weekdayFormat);
    });
  });
  function createAccessibleHeading(node, label) {
    if (!isBrowser)
      return;
    const div = document.createElement("div");
    div.style.cssText = styleToString({
      border: "0px",
      clip: "rect(0px, 0px, 0px, 0px)",
      "clip-path": "inset(50%)",
      height: "1px",
      margin: "-1px",
      overflow: "hidden",
      padding: "0px",
      position: "absolute",
      "white-space": "nowrap",
      width: "1px"
    });
    const h2 = document.createElement("div");
    h2.textContent = label;
    h2.id = ids.accessibleHeading.get();
    h2.role = "heading";
    h2.ariaLevel = "2";
    node.insertBefore(div, node.firstChild);
    div.appendChild(h2);
  }
  function nextPage() {
    const $months = months.get();
    const $numberOfMonths = numberOfMonths.get();
    if (pagedNavigation.get()) {
      const firstMonth = $months[0].value;
      placeholder.set(firstMonth.add({ months: $numberOfMonths }));
    } else {
      const firstMonth = $months[0].value;
      const newMonths = createMonths({
        dateObj: firstMonth.add({ months: 1 }),
        weekStartsOn: weekStartsOn.get(),
        locale: locale.get(),
        fixedWeeks: fixedWeeks.get(),
        numberOfMonths: $numberOfMonths
      });
      months.set(newMonths);
      placeholder.set(newMonths[0].value.set({ day: 1 }));
    }
  }
  function prevPage() {
    const $months = months.get();
    const $numberOfMonths = numberOfMonths.get();
    if (pagedNavigation.get()) {
      const firstMonth = $months[0].value;
      placeholder.set(firstMonth.subtract({ months: $numberOfMonths }));
    } else {
      const firstMonth = $months[0].value;
      const newMonths = createMonths({
        dateObj: firstMonth.subtract({ months: 1 }),
        weekStartsOn: weekStartsOn.get(),
        locale: locale.get(),
        fixedWeeks: fixedWeeks.get(),
        numberOfMonths: $numberOfMonths
      });
      months.set(newMonths);
      placeholder.set(newMonths[0].value.set({ day: 1 }));
    }
  }
  function nextYear() {
    placeholder.add({ years: 1 });
  }
  function prevYear() {
    placeholder.subtract({ years: 1 });
  }
  const ARROW_KEYS = [kbd.ARROW_DOWN, kbd.ARROW_UP, kbd.ARROW_LEFT, kbd.ARROW_RIGHT];
  function setYear(year) {
    placeholder.setDate({ year });
  }
  function setMonth(month) {
    if (month < 0 || month > 11)
      throw new Error("Month must be between 0 and 11");
    placeholder.setDate({ month });
  }
  function handleCellClick(e, date) {
    const $isDateDisabled = isDateDisabled.get();
    const $isDateUnavailable = isDateUnavailable.get();
    if ($isDateDisabled(date) || $isDateUnavailable(date))
      return;
    const $lastPressedDate = lastPressedDateValue.get();
    lastPressedDateValue.set(date);
    const $startValue = startValue.get();
    const $endValue = endValue.get();
    const $highlightedRange = highlightedRange.get();
    if ($startValue && $highlightedRange === null) {
      if ($14e0f24ef4ac5c92$export$ea39ec197993aef0($startValue, date) && !preventDeselect.get() && !$endValue) {
        startValue.set(void 0);
        placeholder.set(date);
        announcer.announce("Selected date is now empty.", "polite");
        return;
      } else if (!$endValue) {
        e.preventDefault();
        if ($lastPressedDate && $14e0f24ef4ac5c92$export$ea39ec197993aef0($lastPressedDate, date)) {
          startValue.set(date);
          announcer.announce(`Selected Date: ${formatter.selectedDate(date, false)}`, "polite");
        }
        return;
      }
    }
    if ($startValue && $endValue && $14e0f24ef4ac5c92$export$ea39ec197993aef0($endValue, date) && !preventDeselect.get()) {
      startValue.set(void 0);
      endValue.set(void 0);
      placeholder.set(date);
      announcer.announce("Selected date is now empty.", "polite");
      return;
    }
    if (!$startValue) {
      startValue.update(() => {
        announcer.announce(`Selected Date: ${formatter.selectedDate(date, false)}`, "polite");
        return date;
      });
    } else if (!$endValue) {
      endValue.update(() => {
        announcer.announce(`Selected Dates: ${formatter.selectedDate($startValue, false)} to ${formatter.selectedDate(date, false)}`, "polite");
        return date;
      });
    } else if ($endValue && $startValue) {
      endValue.set(void 0);
      startValue.update(() => {
        announcer.announce(`Selected Date: ${formatter.selectedDate(date, false)}`, "polite");
        return date;
      });
    }
  }
  const SELECT_KEYS = [kbd.ENTER, kbd.SPACE];
  function handleCalendarKeydown(e) {
    const currentCell = e.target;
    if (!isCalendarCell(currentCell))
      return;
    if (!ARROW_KEYS.includes(e.key) && !SELECT_KEYS.includes(e.key))
      return;
    e.preventDefault();
    if (e.key === kbd.ARROW_DOWN) {
      shiftFocus(currentCell, 7);
    }
    if (e.key === kbd.ARROW_UP) {
      shiftFocus(currentCell, -7);
    }
    if (e.key === kbd.ARROW_LEFT) {
      shiftFocus(currentCell, -1);
    }
    if (e.key === kbd.ARROW_RIGHT) {
      shiftFocus(currentCell, 1);
    }
    if (e.key === kbd.SPACE || e.key === kbd.ENTER) {
      const cellValue = currentCell.getAttribute("data-value");
      if (!cellValue)
        return;
      handleCellClick(e, parseStringToDateValue(cellValue, placeholder.get()));
    }
  }
  function shiftFocus(node, add) {
    const $calendarId = ids.calendar.get();
    const candidateCells = getSelectableCells($calendarId);
    if (!candidateCells.length) {
      return;
    }
    const index = candidateCells.indexOf(node);
    const nextIndex = index + add;
    if (isValidIndex(nextIndex, candidateCells)) {
      const nextCell = candidateCells[nextIndex];
      setPlaceholderToNodeValue(nextCell, placeholder);
      return nextCell.focus();
    }
    if (nextIndex < 0) {
      if (isPrevButtonDisabled.get())
        return;
      const $months = months.get();
      const firstMonth = $months[0].value;
      const $numberOfMonths = numberOfMonths.get();
      placeholder.set(firstMonth.subtract({ months: $numberOfMonths }));
      tick().then(() => {
        const newCandidateCells = getSelectableCells($calendarId);
        if (!newCandidateCells.length) {
          return;
        }
        const newIndex = newCandidateCells.length - Math.abs(nextIndex);
        if (isValidIndex(newIndex, newCandidateCells)) {
          const newCell = newCandidateCells[newIndex];
          setPlaceholderToNodeValue(newCell, placeholder);
          return newCell.focus();
        }
      });
    }
    if (nextIndex >= candidateCells.length) {
      if (isNextButtonDisabled.get())
        return;
      const $months = months.get();
      const firstMonth = $months[0].value;
      const $numberOfMonths = numberOfMonths.get();
      placeholder.set(firstMonth.add({ months: $numberOfMonths }));
      tick().then(() => {
        const newCandidateCells = getSelectableCells($calendarId);
        if (!newCandidateCells.length) {
          return;
        }
        const newIndex = nextIndex - candidateCells.length;
        if (isValidIndex(newIndex, newCandidateCells)) {
          const nextCell = newCandidateCells[newIndex];
          return nextCell.focus();
        }
      });
    }
  }
  const _isDateDisabled = derived([isDateDisabled, placeholder, minValue, maxValue], ([$isDateDisabled, $placeholder, $minValue, $maxValue]) => {
    return (date) => {
      if ($isDateDisabled(date))
        return true;
      if ($minValue && isBefore(date, $minValue))
        return true;
      if ($maxValue && isAfter(date, $maxValue))
        return true;
      if (!$14e0f24ef4ac5c92$export$a18c89cbd24170ff(date, $placeholder))
        return true;
      return false;
    };
  });
  effect([value], ([$value]) => {
    const $startValue = startValue.get();
    const $endValue = endValue.get();
    if (($value == null ? void 0 : $value.start) && ($value == null ? void 0 : $value.end)) {
      if ($value.start !== $startValue) {
        startValue.set($value.start);
      }
      if ($value.end !== $endValue) {
        endValue.set($value.end);
      }
      return;
    }
  });
  effect([startValue, endValue], ([$startValue, $endValue]) => {
    const $value = value.get();
    if ($value && ($value == null ? void 0 : $value.start) === $startValue && ($value == null ? void 0 : $value.end) === $endValue)
      return;
    if ($startValue && $endValue) {
      value.update((prev2) => {
        if ((prev2 == null ? void 0 : prev2.start) === $startValue && (prev2 == null ? void 0 : prev2.end) === $endValue) {
          return prev2;
        }
        if (isBefore($endValue, $startValue)) {
          return {
            start: $endValue,
            end: $startValue
          };
        } else {
          return {
            start: $startValue,
            end: $endValue
          };
        }
      });
    } else if ($value && $value.start && $value.end) {
      value.set({
        start: void 0,
        end: void 0
      });
    }
  });
  return {
    elements: {
      calendar,
      heading,
      grid,
      cell,
      nextButton,
      prevButton
    },
    states: {
      placeholder: placeholder.toWritable(),
      months,
      weekdays,
      headingValue,
      value,
      startValue,
      endValue
    },
    helpers: {
      nextPage,
      prevPage,
      nextYear,
      prevYear,
      setYear,
      setMonth,
      isDateDisabled: _isDateDisabled,
      isDateUnavailable
    },
    options,
    ids
  };
}

// node_modules/@melt-ui/svelte/dist/builders/scroll-area/helpers.js
function debounceCallback(cb, delay3) {
  let debounceTimer = 0;
  safeOnDestroy(() => {
    clearTimeout(debounceTimer);
  });
  return () => {
    window.clearTimeout(debounceTimer);
    debounceTimer = window.setTimeout(cb, delay3);
  };
}
function resizeObserver(node, handleResize) {
  let animationFrame = 0;
  const observer = new ResizeObserver(() => {
    cancelAnimationFrame(animationFrame);
    animationFrame = requestAnimationFrame(handleResize);
  });
  observer.observe(node);
  return () => {
    window.cancelAnimationFrame(animationFrame);
    observer.unobserve(node);
  };
}
function addUnlinkedScrollListener(node, handler = noop2) {
  let prevPosition = { left: node.scrollLeft, top: node.scrollTop };
  let rAF = 0;
  (function loop() {
    const position = { left: node.scrollLeft, top: node.scrollTop };
    const isHorizontalScroll = prevPosition.left !== position.left;
    const isVerticalScroll = prevPosition.top !== position.top;
    if (isHorizontalScroll || isVerticalScroll)
      handler();
    prevPosition = position;
    rAF = window.requestAnimationFrame(loop);
  })();
  return () => window.cancelAnimationFrame(rAF);
}
function isScrollingWithinScrollbarBounds(scrollPos, maxScrollPos) {
  return scrollPos > 0 && scrollPos < maxScrollPos;
}
function linearScale(input, output) {
  return (value) => {
    if (input[0] === input[1] || output[0] === output[1])
      return output[0];
    const ratio = (output[1] - output[0]) / (input[1] - input[0]);
    return output[0] + ratio * (value - input[0]);
  };
}
function toInt(value) {
  return value ? parseInt(value, 10) : 0;
}
function getThumbRatio(viewportSize, contentSize) {
  const ratio = viewportSize / contentSize;
  return isNaN(ratio) ? 0 : ratio;
}
function getThumbSize(sizes) {
  const ratio = getThumbRatio(sizes.viewport, sizes.content);
  const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
  const thumbSize = (sizes.scrollbar.size - scrollbarPadding) * ratio;
  return Math.max(thumbSize, 18);
}
function getScrollPositionFromPointer(pointerPos, pointerOffset, sizes, dir = "ltr") {
  const thumbSizePx = getThumbSize(sizes);
  const thumbCenter = thumbSizePx / 2;
  const offset2 = pointerOffset || thumbCenter;
  const thumbOffsetFromEnd = thumbSizePx - offset2;
  const minPointerPos = sizes.scrollbar.paddingStart + offset2;
  const maxPointerPos = sizes.scrollbar.size - sizes.scrollbar.paddingEnd - thumbOffsetFromEnd;
  const maxScrollPos = sizes.content - sizes.viewport;
  const scrollRange = dir === "ltr" ? [0, maxScrollPos] : [maxScrollPos * -1, 0];
  const interpolate = linearScale([minPointerPos, maxPointerPos], scrollRange);
  return interpolate(pointerPos);
}
function getThumbOffsetFromScroll(scrollPos, sizes, dir = "ltr") {
  const thumbSizePx = getThumbSize(sizes);
  const scrollbarPadding = sizes.scrollbar.paddingStart + sizes.scrollbar.paddingEnd;
  const scrollbar = sizes.scrollbar.size - scrollbarPadding;
  const maxScrollPos = sizes.content - sizes.viewport;
  const maxThumbPos = scrollbar - thumbSizePx;
  const [scrollClampMin, scrollClampMax] = dir === "ltr" ? [0, maxScrollPos] : [maxScrollPos * -1, 0];
  const scrollWithoutMomentum = clamp(scrollClampMin, scrollPos, scrollClampMax);
  const interpolate = linearScale([0, maxScrollPos], [0, maxThumbPos]);
  return interpolate(scrollWithoutMomentum);
}

// node_modules/@melt-ui/svelte/dist/internal/helpers/store/stateMachine.js
function createStateMachine(initialState, machine) {
  const state = withGet.writable(initialState);
  function reducer(event) {
    const $state = state.get();
    const nextState = machine[$state][event];
    return nextState ?? $state;
  }
  const dispatch = (event) => {
    state.set(reducer(event));
  };
  return {
    state,
    dispatch
  };
}

// node_modules/@melt-ui/svelte/dist/builders/scroll-area/scrollbars.js
function createBaseScrollbarAction(state) {
  const { rootState, scrollbarState } = state;
  scrollbarState.isVisible.set(true);
  function handleDragScroll(e) {
    const $domRect = scrollbarState.domRect.get();
    if (!$domRect)
      return;
    const x = e.clientX - $domRect.left;
    const y = e.clientY - $domRect.top;
    const $isHorizontal = scrollbarState.isHorizontal.get();
    if ($isHorizontal) {
      scrollbarState.onDragScroll(x);
    } else {
      scrollbarState.onDragScroll(y);
    }
  }
  function handlePointerDown(e) {
    if (e.button !== 0)
      return;
    const target = e.target;
    if (!isHTMLElement(target))
      return;
    target.setPointerCapture(e.pointerId);
    const currentTarget = e.currentTarget;
    if (!isHTMLElement(currentTarget))
      return;
    scrollbarState.domRect.set(currentTarget.getBoundingClientRect());
    scrollbarState.prevWebkitUserSelect.set(document.body.style.webkitUserSelect);
    document.body.style.webkitUserSelect = "none";
    const $viewportEl = rootState.viewportEl.get();
    if ($viewportEl) {
      $viewportEl.style.scrollBehavior = "auto";
    }
    handleDragScroll(e);
  }
  function handlePointerMove(e) {
    handleDragScroll(e);
  }
  function handlePointerUp(e) {
    const target = e.target;
    if (!isHTMLElement(target))
      return;
    if (target.hasPointerCapture(e.pointerId)) {
      target.releasePointerCapture(e.pointerId);
    }
    document.body.style.webkitUserSelect = scrollbarState.prevWebkitUserSelect.get();
    const $viewportEl = rootState.viewportEl.get();
    if ($viewportEl) {
      $viewportEl.style.scrollBehavior = "";
    }
    scrollbarState.domRect.set(null);
  }
  function handleWheel(e) {
    const target = e.target;
    const currentTarget = e.currentTarget;
    if (!isHTMLElement(target) || !isHTMLElement(currentTarget))
      return;
    const isScrollbarWheel = currentTarget.contains(target);
    if (!isScrollbarWheel)
      return;
    const $sizes = scrollbarState.sizes.get();
    if (!$sizes)
      return;
    const maxScrollPos = $sizes.content - $sizes.viewport;
    scrollbarState.handleWheelScroll(e, maxScrollPos);
  }
  function baseAction(node) {
    scrollbarState.scrollbarEl.set(node);
    const unsubEvents = executeCallbacks(addMeltEventListener(node, "pointerdown", handlePointerDown), addMeltEventListener(node, "pointermove", handlePointerMove), addMeltEventListener(node, "pointerup", handlePointerUp), addEventListener(document, "wheel", handleWheel, { passive: false }));
    const unsubResizeContent = effect([rootState.contentEl], ([$contentEl]) => {
      if (!$contentEl)
        return noop2;
      return resizeObserver($contentEl, scrollbarState.handleSizeChange);
    });
    return {
      destroy() {
        unsubEvents();
        unsubResizeContent();
      }
    };
  }
  return baseAction;
}
function createAutoScrollbarAction(state) {
  const baseAction = createBaseScrollbarAction(state);
  const { rootState, scrollbarState } = state;
  const handleResize = debounceCallback(() => {
    const $viewportEl = rootState.viewportEl.get();
    if (!$viewportEl)
      return;
    const isOverflowX = $viewportEl.offsetWidth < $viewportEl.scrollWidth;
    const isOverflowY = $viewportEl.offsetHeight < $viewportEl.scrollHeight;
    scrollbarState.isVisible.set(scrollbarState.isHorizontal.get() ? isOverflowX : isOverflowY);
  }, 10);
  function scrollbarAutoAction(node) {
    var _a;
    const unsubBaseAction = (_a = baseAction(node)) == null ? void 0 : _a.destroy;
    handleResize();
    const unsubObservers = [];
    const $viewportEl = rootState.viewportEl.get();
    if ($viewportEl) {
      unsubObservers.push(resizeObserver($viewportEl, handleResize));
    }
    const $contentEl = rootState.contentEl.get();
    if ($contentEl) {
      unsubObservers.push(resizeObserver($contentEl, handleResize));
    }
    return {
      destroy() {
        unsubObservers.forEach((unsub) => unsub());
        unsubBaseAction();
      }
    };
  }
  return scrollbarAutoAction;
}
function createHoverScrollbarAction(state) {
  const baseAction = createBaseScrollbarAction(state);
  const { rootState, scrollbarState } = state;
  scrollbarState.isVisible.set(false);
  let timeout;
  function handlePointerEnter() {
    window.clearTimeout(timeout);
    if (scrollbarState.isVisible.get())
      return;
    const $viewportEl = rootState.viewportEl.get();
    if (!$viewportEl)
      return;
    const isOverflowX = $viewportEl.offsetWidth < $viewportEl.scrollWidth;
    const isOverflowY = $viewportEl.offsetHeight < $viewportEl.scrollHeight;
    scrollbarState.isVisible.set(scrollbarState.isHorizontal.get() ? isOverflowX : isOverflowY);
  }
  function handlePointerLeave() {
    timeout = window.setTimeout(() => {
      if (!scrollbarState.isVisible.get())
        return;
      scrollbarState.isVisible.set(false);
    }, rootState.options.hideDelay.get());
  }
  function scrollbarHoverAction(node) {
    var _a;
    const unsubBaseAction = (_a = baseAction(node)) == null ? void 0 : _a.destroy;
    const scrollAreaEl = node.closest("[data-melt-scroll-area]");
    let unsubScrollAreaListeners = noop2;
    if (scrollAreaEl) {
      if (isTouchDevice()) {
        unsubScrollAreaListeners = executeCallbacks(addEventListener(scrollAreaEl, "touchstart", handlePointerEnter), addEventListener(scrollAreaEl, "touchend", handlePointerLeave));
      } else if (isFirefox()) {
        unsubScrollAreaListeners = executeCallbacks(addEventListener(scrollAreaEl, "pointerenter", handlePointerEnter), addEventListener(scrollAreaEl, "mouseenter", handlePointerEnter), addEventListener(scrollAreaEl, "mouseleave", handlePointerLeave));
      } else {
        unsubScrollAreaListeners = executeCallbacks(addEventListener(scrollAreaEl, "pointerenter", handlePointerEnter), addEventListener(scrollAreaEl, "pointerleave", handlePointerLeave));
      }
    }
    return {
      destroy() {
        unsubBaseAction == null ? void 0 : unsubBaseAction();
        unsubScrollAreaListeners();
      }
    };
  }
  return scrollbarHoverAction;
}
function createScrollScrollbarAction(state) {
  const baseAction = createBaseScrollbarAction(state);
  const { rootState, scrollbarState } = state;
  const machine = createStateMachine("hidden", {
    hidden: {
      SCROLL: "scrolling"
    },
    scrolling: {
      SCROLL_END: "idle",
      POINTER_ENTER: "interacting"
    },
    interacting: {
      SCROLL: "interacting",
      POINTER_LEAVE: "idle"
    },
    idle: {
      HIDE: "hidden",
      SCROLL: "scrolling",
      POINTER_ENTER: "interacting"
    }
  });
  effect([machine.state], ([$status]) => {
    if ($status === "idle") {
      window.setTimeout(() => {
        machine.dispatch("HIDE");
      }, rootState.options.hideDelay.get());
    }
    if ($status === "hidden") {
      scrollbarState.isVisible.set(false);
    } else {
      scrollbarState.isVisible.set(true);
    }
  });
  const debounceScrollEnd = debounceCallback(() => machine.dispatch("SCROLL_END"), 100);
  effect([rootState.viewportEl, scrollbarState.isHorizontal], ([$viewportEl, $isHorizontal]) => {
    const scrollDirection = $isHorizontal ? "scrollLeft" : "scrollTop";
    let unsub = noop2;
    if ($viewportEl) {
      let prevScrollPos = $viewportEl[scrollDirection];
      const handleScroll = () => {
        const scrollPos = $viewportEl[scrollDirection];
        const hasScrollInDirectionChanged = prevScrollPos !== scrollPos;
        if (hasScrollInDirectionChanged) {
          machine.dispatch("SCROLL");
          debounceScrollEnd();
        }
        prevScrollPos = scrollPos;
      };
      unsub = addEventListener($viewportEl, "scroll", handleScroll);
    }
    return () => {
      unsub();
    };
  });
  function scrollbarScrollAction(node) {
    var _a;
    const unsubBaseAction = (_a = baseAction(node)) == null ? void 0 : _a.destroy;
    const unsubListeners = executeCallbacks(addEventListener(node, "pointerenter", () => machine.dispatch("POINTER_ENTER")), addEventListener(node, "pointerleave", () => machine.dispatch("POINTER_LEAVE")));
    return {
      destroy() {
        unsubBaseAction == null ? void 0 : unsubBaseAction();
        unsubListeners();
      }
    };
  }
  return scrollbarScrollAction;
}
function createScrollbarX(state, createAction) {
  const action = createAction(state);
  const { rootState, scrollbarState } = state;
  return makeElement(name17("scrollbar"), {
    stores: [scrollbarState.sizes, rootState.options.dir, scrollbarState.isVisible],
    returned: ([$sizes, $dir, $isVisible]) => {
      return {
        style: styleToString({
          position: "absolute",
          bottom: 0,
          left: $dir === "rtl" ? "var(--melt-scroll-area-corner-width)" : 0,
          right: $dir === "ltr" ? "var(--melt-scroll-area-corner-width)" : 0,
          "--melt-scroll-area-thumb-width": `${getThumbSize($sizes)}px`,
          visibility: !$isVisible ? "hidden" : void 0
        }),
        "data-state": $isVisible ? "visible" : "hidden"
      };
    },
    action: (node) => {
      var _a;
      const unsubAction = (_a = action(node)) == null ? void 0 : _a.destroy;
      rootState.scrollbarXEl.set(node);
      rootState.scrollbarXEnabled.set(true);
      return {
        destroy() {
          unsubAction == null ? void 0 : unsubAction();
          rootState.scrollbarXEl.set(null);
        }
      };
    }
  });
}
function createScrollbarY(state, createAction) {
  const action = createAction(state);
  const { rootState, scrollbarState } = state;
  return makeElement(name17("scrollbar"), {
    stores: [scrollbarState.sizes, rootState.options.dir, scrollbarState.isVisible],
    returned: ([$sizes, $dir, $isVisible]) => {
      return {
        style: styleToString({
          position: "absolute",
          top: 0,
          right: $dir === "ltr" ? 0 : void 0,
          left: $dir === "rtl" ? 0 : void 0,
          bottom: "var(--melt-scroll-area-corner-height)",
          "--melt-scroll-area-thumb-height": `${getThumbSize($sizes)}px`,
          visibility: !$isVisible ? "hidden" : void 0
        }),
        "data-state": $isVisible ? "visible" : "hidden"
      };
    },
    action: (node) => {
      var _a;
      const unsubAction = (_a = action(node)) == null ? void 0 : _a.destroy;
      rootState.scrollbarYEl.set(node);
      rootState.scrollbarYEnabled.set(true);
      return {
        destroy() {
          unsubAction == null ? void 0 : unsubAction();
          rootState.scrollbarYEl.set(null);
        }
      };
    }
  });
}
function getScrollbarActionByType(type) {
  switch (type) {
    case "always":
      return createBaseScrollbarAction;
    case "auto":
      return createAutoScrollbarAction;
    case "hover":
      return createHoverScrollbarAction;
    case "scroll":
      return createScrollScrollbarAction;
    default:
      return createBaseScrollbarAction;
  }
}

// node_modules/@melt-ui/svelte/dist/builders/scroll-area/create.js
var { name: name17 } = createElHelpers("scroll-area");
var scrollAreaIdParts = [
  "root",
  "viewport",
  "content",
  "scrollbarX",
  "scrollbarY",
  "thumbX",
  "thumbY"
];
var defaults25 = {
  type: "hover",
  hideDelay: 600,
  dir: "ltr"
};
function createScrollArea(props) {
  const withDefaults = { ...defaults25, ...props };
  const options = toWritableStores(omit(withDefaults, "ids"));
  const cornerWidth = withGet.writable(0);
  const cornerHeight = withGet.writable(0);
  const scrollbarXEnabled = withGet.writable(false);
  const scrollbarYEnabled = withGet.writable(false);
  const scrollAreaEl = withGet.writable(null);
  const viewportEl = withGet.writable(null);
  const contentEl = withGet.writable(null);
  const scrollbarXEl = withGet.writable(null);
  const scrollbarYEl = withGet.writable(null);
  const ids = toWritableStores({ ...generateIds(scrollAreaIdParts), ...withDefaults.ids });
  const rootState = {
    cornerWidth,
    cornerHeight,
    scrollbarXEnabled,
    scrollbarYEnabled,
    viewportEl,
    contentEl,
    options,
    scrollbarXEl,
    scrollbarYEl,
    scrollAreaEl,
    ids
  };
  const root = makeElement(name17(), {
    stores: [cornerWidth, cornerHeight, ids.root],
    returned: ([$cornerWidth, $cornderHeight, $rootId]) => {
      return {
        style: styleToString({
          position: "relative",
          "--melt-scroll-area-corner-width": `${$cornerWidth}px`,
          "--melt-scroll-area-corner-height": `${$cornderHeight}px`
        }),
        id: $rootId
      };
    },
    action: (node) => {
      scrollAreaEl.set(node);
      return {
        destroy() {
          scrollAreaEl.set(null);
        }
      };
    }
  });
  const viewport = makeElement(name17("viewport"), {
    stores: [scrollbarXEnabled, scrollbarYEnabled, ids.viewport],
    returned: ([$scrollbarXEnabled, $scrollbarYEnabled, $viewportId]) => {
      return {
        style: styleToString({
          "scrollbar-width": "none",
          "-ms-overflow-style": "none",
          "-webkit-overflow-scrolling": "touch",
          "-webkit-scrollbar": "none",
          "overflow-x": $scrollbarXEnabled ? "scroll" : "hidden",
          "overflow-y": $scrollbarYEnabled ? "scroll" : "hidden"
        }),
        id: $viewportId
      };
    },
    action: (node) => {
      var _a;
      const styleNode = document.createElement("style");
      styleNode.innerHTML = `
				/* Hide scrollbars cross-browser and enable momentum scroll for touch
					devices */
				[data-melt-scroll-area-viewport] {
					scrollbar-width: none;
					-ms-overflow-style: none;
					-webkit-overflow-scrolling: touch;
				}

				[data-melt-scroll-area-viewport]::-webkit-scrollbar {
					display: none;
				}
			`;
      (_a = node.parentElement) == null ? void 0 : _a.insertBefore(styleNode, node);
      viewportEl.set(node);
      return {
        destroy() {
          styleNode.remove();
          viewportEl.set(null);
        }
      };
    }
  });
  const content = makeElement(name17("content"), {
    stores: [ids.content],
    returned: ([$contentId]) => {
      return {
        style: styleToString({
          "min-width": "100%",
          display: "table"
        }),
        id: $contentId
      };
    },
    action: (node) => {
      contentEl.set(node);
      return {
        destroy() {
          contentEl.set(null);
        }
      };
    }
  });
  function createScrollbar(orientationProp = "vertical") {
    const orientation = withGet.writable(orientationProp);
    const isHorizontal = withGet.writable(orientationProp === "horizontal");
    const domRect = withGet.writable(null);
    const prevWebkitUserSelect = withGet.writable("");
    const pointerOffset = withGet.writable(0);
    const thumbEl = withGet.writable(null);
    const thumbOffset = withGet.writable(0);
    const scrollbarEl = withGet.writable(null);
    const sizes = withGet.writable({
      content: 0,
      viewport: 0,
      scrollbar: {
        size: 0,
        paddingStart: 0,
        paddingEnd: 0
      }
    });
    const isVisible = withGet.writable(false);
    const hasThumb = withGet.derived(sizes, ($sizes) => {
      const thumbRatio = getThumbRatio($sizes.viewport, $sizes.content);
      return Boolean(thumbRatio > 0 && thumbRatio < 1);
    });
    function getScrollPosition(pointerPos, dir) {
      return getScrollPositionFromPointer(pointerPos, pointerOffset.get(), sizes.get(), dir);
    }
    function handleWheelScroll(e, payload) {
      const $viewportEl = viewportEl.get();
      if (!$viewportEl)
        return;
      if (isHorizontal.get()) {
        const scrollPos = $viewportEl.scrollLeft + e.deltaY;
        $viewportEl.scrollLeft = scrollPos;
        if (isScrollingWithinScrollbarBounds(scrollPos, payload)) {
          e.preventDefault();
        }
      } else {
        const scrollPos = $viewportEl.scrollTop + e.deltaY;
        $viewportEl.scrollTop = scrollPos;
        if (isScrollingWithinScrollbarBounds(scrollPos, payload)) {
          e.preventDefault();
        }
      }
    }
    function handleThumbDown(payload) {
      if (isHorizontal.get()) {
        pointerOffset.set(payload.x);
      } else {
        pointerOffset.set(payload.y);
      }
    }
    function handleThumbUp() {
      pointerOffset.set(0);
    }
    function onThumbPositionChange() {
      const $viewportEl = viewportEl.get();
      const $thumbEl = thumbEl.get();
      if (!$viewportEl || !$thumbEl)
        return;
      const scrollPos = isHorizontal.get() ? $viewportEl.scrollLeft : $viewportEl.scrollTop;
      const offset2 = getThumbOffsetFromScroll(scrollPos, sizes.get(), rootState.options.dir.get());
      thumbOffset.set(offset2);
    }
    function onDragScroll(payload) {
      const $viewportEl = viewportEl.get();
      if (!$viewportEl)
        return;
      if (isHorizontal.get()) {
        $viewportEl.scrollLeft = getScrollPosition(payload, rootState.options.dir.get());
      } else {
        $viewportEl.scrollTop = getScrollPosition(payload);
      }
    }
    function handleSizeChange() {
      const $scrollbarEl = scrollbarState.scrollbarEl.get();
      if (!$scrollbarEl)
        return;
      const $isHorizontal = scrollbarState.isHorizontal.get();
      const $viewportEl = rootState.viewportEl.get();
      if ($isHorizontal) {
        scrollbarState.sizes.set({
          content: ($viewportEl == null ? void 0 : $viewportEl.scrollWidth) ?? 0,
          viewport: ($viewportEl == null ? void 0 : $viewportEl.offsetWidth) ?? 0,
          scrollbar: {
            size: $scrollbarEl.clientWidth ?? 0,
            paddingStart: toInt(getComputedStyle($scrollbarEl).paddingLeft),
            paddingEnd: toInt(getComputedStyle($scrollbarEl).paddingRight)
          }
        });
      } else {
        scrollbarState.sizes.set({
          content: ($viewportEl == null ? void 0 : $viewportEl.scrollHeight) ?? 0,
          viewport: ($viewportEl == null ? void 0 : $viewportEl.offsetHeight) ?? 0,
          scrollbar: {
            size: $scrollbarEl.clientHeight ?? 0,
            paddingStart: toInt(getComputedStyle($scrollbarEl).paddingLeft),
            paddingEnd: toInt(getComputedStyle($scrollbarEl).paddingRight)
          }
        });
      }
    }
    const scrollbarState = {
      isHorizontal,
      domRect,
      prevWebkitUserSelect,
      pointerOffset,
      thumbEl,
      thumbOffset,
      sizes,
      orientation,
      handleThumbDown,
      handleThumbUp,
      onThumbPositionChange,
      onDragScroll,
      handleWheelScroll,
      hasThumb,
      scrollbarEl,
      isVisible,
      handleSizeChange
    };
    const scrollbarActionByType = getScrollbarActionByType(options.type.get());
    const scrollAreaState = { rootState, scrollbarState };
    const scrollbar = orientationProp === "horizontal" ? createScrollbarX(scrollAreaState, scrollbarActionByType) : createScrollbarY(scrollAreaState, scrollbarActionByType);
    const thumb = createScrollbarThumb(scrollAreaState);
    return {
      scrollbar,
      thumb
    };
  }
  const { scrollbar: scrollbarX, thumb: thumbX } = createScrollbar("horizontal");
  const { scrollbar: scrollbarY, thumb: thumbY } = createScrollbar("vertical");
  const corner = createScrollAreaCorner(rootState);
  return {
    options,
    elements: {
      root,
      viewport,
      content,
      corner,
      scrollbarX,
      scrollbarY,
      thumbX,
      thumbY
    }
  };
}
function createScrollbarThumb(state) {
  const { scrollbarState, rootState } = state;
  function handlePointerDown(e) {
    const thumb2 = e.target;
    if (!isHTMLElement(thumb2))
      return;
    const thumbRect = thumb2.getBoundingClientRect();
    const x = e.clientX - thumbRect.left;
    const y = e.clientY - thumbRect.top;
    scrollbarState.handleThumbDown({ x, y });
  }
  function handlePointerUp(e) {
    scrollbarState.handleThumbUp(e);
  }
  let unsubListener = void 0;
  function handleScroll() {
    if (unsubListener)
      return;
    const $viewportEl = rootState.viewportEl.get();
    if ($viewportEl) {
      unsubListener = addUnlinkedScrollListener($viewportEl, scrollbarState.onThumbPositionChange);
    }
    scrollbarState.onThumbPositionChange();
  }
  const thumb = makeElement(name17("thumb"), {
    stores: [scrollbarState.hasThumb, scrollbarState.isHorizontal, scrollbarState.thumbOffset],
    returned: ([$hasThumb, $isHorizontal, $offset]) => {
      return {
        style: styleToString({
          width: "var(--melt-scroll-area-thumb-width)",
          height: "var(--melt-scroll-area-thumb-height)",
          transform: $isHorizontal ? `translate3d(${Math.round($offset)}px, 0, 0)` : `translate3d(0, ${Math.round($offset)}px, 0)`
        }),
        "data-state": $hasThumb ? "visible" : "hidden"
      };
    },
    action: (node) => {
      scrollbarState.thumbEl.set(node);
      const unsubEffect = effect([scrollbarState.sizes], ([_]) => {
        const $viewportEl = rootState.viewportEl.get();
        if (!$viewportEl)
          return noop2;
        scrollbarState.onThumbPositionChange();
        return addEventListener($viewportEl, "scroll", handleScroll);
      });
      const unsubEvents = executeCallbacks(addMeltEventListener(node, "pointerdown", handlePointerDown), addMeltEventListener(node, "pointerup", handlePointerUp));
      return {
        destroy() {
          unsubListener == null ? void 0 : unsubListener();
          unsubEvents();
          unsubEffect();
        }
      };
    }
  });
  return thumb;
}
function createScrollAreaCorner(rootState) {
  const width = writable(0);
  const height = writable(0);
  const hasSize = derived([width, height], ([$width, $height]) => !!$width && !!$height);
  function setCornerHeight() {
    var _a;
    const offsetHeight = ((_a = rootState.scrollbarXEl.get()) == null ? void 0 : _a.offsetHeight) || 0;
    rootState.cornerHeight.set(offsetHeight);
    height.set(offsetHeight);
  }
  function setCornerWidth() {
    var _a;
    const offsetWidth = ((_a = rootState.scrollbarYEl.get()) == null ? void 0 : _a.offsetWidth) || 0;
    rootState.cornerWidth.set(offsetWidth);
    width.set(offsetWidth);
  }
  effect([rootState.scrollbarXEl], ([$scrollbarXEl]) => {
    if ($scrollbarXEl) {
      setCornerHeight();
    }
  });
  effect([rootState.scrollbarYEl], ([$scrollbarYEl]) => {
    if ($scrollbarYEl) {
      setCornerWidth();
    }
  });
  const hasBothScrollbarsVisible = derived([rootState.scrollbarXEl, rootState.scrollbarYEl], ([$scrollbarXEl, $scrollbarYEl]) => {
    return !!$scrollbarXEl && !!$scrollbarYEl;
  });
  const hasCorner = derived([rootState.options.type, hasBothScrollbarsVisible], ([$type, $hasBoth]) => {
    return $type !== "scroll" && $hasBoth;
  });
  const shouldDisplay = derived([hasCorner, hasSize], ([$hasCorner, $hasSize]) => $hasCorner && $hasSize);
  const corner = makeElement(name17("corner"), {
    stores: [width, height, rootState.options.dir, shouldDisplay],
    returned: ([$width, $height, $dir, $shouldDisplay]) => {
      return {
        style: styleToString({
          display: $shouldDisplay ? "block" : "none",
          width: `${$width}px`,
          height: `${$height}px`,
          position: "absolute",
          right: $dir === "ltr" ? 0 : void 0,
          left: $dir === "rtl" ? 0 : void 0,
          bottom: 0
        })
      };
    }
  });
  return corner;
}

// node_modules/@melt-ui/svelte/dist/builders/select/create.js
function createSelect(props) {
  const listbox = createListbox({ ...props, builder: "select" });
  const selectedLabel = derived(listbox.states.selected, ($selected) => {
    if (Array.isArray($selected)) {
      return $selected.map((o) => o.label).join(", ");
    }
    return ($selected == null ? void 0 : $selected.label) ?? "";
  });
  return {
    ...listbox,
    elements: {
      ...listbox.elements
    },
    states: {
      ...listbox.states,
      selectedLabel
    }
  };
}

// node_modules/@melt-ui/svelte/dist/builders/separator/create.js
var defaults26 = {
  orientation: "horizontal",
  decorative: false
};
var createSeparator = (props) => {
  const withDefaults = { ...defaults26, ...props };
  const options = toWritableStores(withDefaults);
  const { orientation, decorative } = options;
  const root = makeElement("separator", {
    stores: [orientation, decorative],
    returned: ([$orientation, $decorative]) => {
      const ariaOrientation = $orientation === "vertical" ? $orientation : void 0;
      return {
        role: $decorative ? "none" : "separator",
        "aria-orientation": ariaOrientation,
        "aria-hidden": $decorative,
        "data-orientation": $orientation
      };
    }
  });
  return {
    elements: {
      root
    },
    options
  };
};

// node_modules/@melt-ui/svelte/dist/builders/slider/create.js
var defaults27 = {
  defaultValue: [],
  min: 0,
  max: 100,
  step: 1,
  orientation: "horizontal",
  dir: "ltr",
  disabled: false
};
var { name: name18 } = createElHelpers("slider");
var createSlider = (props) => {
  const withDefaults = { ...defaults27, ...props };
  const options = toWritableStores(omit(withDefaults, "value", "onValueChange", "defaultValue"));
  const { min: min2, max: max2, step, orientation, dir, disabled } = options;
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults == null ? void 0 : withDefaults.onValueChange);
  const isActive = withGet(writable(false));
  const currentThumbIndex = withGet(writable(0));
  const activeThumb = withGet(writable(null));
  const meltIds = generateIds(["root"]);
  const updatePosition = (val, index) => {
    value.update((prev2) => {
      if (!prev2)
        return [val];
      if (prev2[index] === val)
        return prev2;
      const newValue = [...prev2];
      const direction2 = newValue[index] > val ? -1 : 1;
      function swap() {
        newValue[index] = newValue[index + direction2];
        newValue[index + direction2] = val;
        const thumbs2 = getAllThumbs();
        if (thumbs2) {
          thumbs2[index + direction2].focus();
          activeThumb.set({ thumb: thumbs2[index + direction2], index: index + direction2 });
        }
      }
      if (direction2 === -1 && val < newValue[index - 1]) {
        swap();
        return newValue;
      } else if (direction2 === 1 && val > newValue[index + 1]) {
        swap();
        return newValue;
      }
      const $min = min2.get();
      const $max = max2.get();
      const $step = step.get();
      newValue[index] = snapValueToStep(val, $min, $max, $step);
      return newValue;
    });
  };
  const getAllThumbs = () => {
    const root2 = getElementByMeltId(meltIds.root);
    if (!root2)
      return null;
    return Array.from(root2.querySelectorAll('[data-melt-part="thumb"]')).filter((thumb) => isHTMLElement(thumb));
  };
  const position = derived([min2, max2], ([$min, $max]) => {
    return (val) => {
      const pos = (val - $min) / ($max - $min) * 100;
      return pos;
    };
  });
  const direction = withGet.derived([orientation, dir], ([$orientation, $dir]) => {
    if ($orientation === "horizontal") {
      return $dir === "rtl" ? "rl" : "lr";
    } else {
      return $dir === "rtl" ? "tb" : "bt";
    }
  });
  const root = makeElement(name18(), {
    stores: [disabled, orientation, dir],
    returned: ([$disabled, $orientation, $dir]) => {
      return {
        dir: $dir,
        disabled: disabledAttr($disabled),
        "data-disabled": disabledAttr($disabled),
        "data-orientation": $orientation,
        style: $disabled ? void 0 : `touch-action: ${$orientation === "horizontal" ? "pan-y" : "pan-x"}`,
        "data-melt-id": meltIds.root
      };
    }
  });
  const range = makeElement(name18("range"), {
    stores: [value, direction, position],
    returned: ([$value, $direction, $position]) => {
      const minimum = $value.length > 1 ? $position(Math.min(...$value) ?? 0) : 0;
      const maximum = 100 - $position(Math.max(...$value) ?? 0);
      const style = {
        position: "absolute"
      };
      switch ($direction) {
        case "lr": {
          style.left = `${minimum}%`;
          style.right = `${maximum}%`;
          break;
        }
        case "rl": {
          style.right = `${minimum}%`;
          style.left = `${maximum}%`;
          break;
        }
        case "bt": {
          style.bottom = `${minimum}%`;
          style.top = `${maximum}%`;
          break;
        }
        case "tb": {
          style.top = `${minimum}%`;
          style.bottom = `${maximum}%`;
          break;
        }
      }
      return {
        style: styleToString(style)
      };
    }
  });
  const thumbs = makeElementArray(name18("thumb"), {
    stores: [value, position, min2, max2, disabled, orientation, direction],
    returned: ([$value, $position, $min, $max, $disabled, $orientation, $direction]) => {
      const result = Array.from({ length: $value.length || 1 }, (_, i) => {
        const currentThumb = currentThumbIndex.get();
        if (currentThumb < $value.length) {
          currentThumbIndex.update((prev2) => prev2 + 1);
        }
        const thumbValue = $value[i];
        const thumbPosition = `${$position(thumbValue)}%`;
        const style = {
          position: "absolute"
        };
        switch ($direction) {
          case "lr": {
            style.left = thumbPosition;
            style.translate = "-50% 0";
            break;
          }
          case "rl": {
            style.right = thumbPosition;
            style.translate = "50% 0";
            break;
          }
          case "bt": {
            style.bottom = thumbPosition;
            style.translate = "0 50%";
            break;
          }
          case "tb": {
            style.top = thumbPosition;
            style.translate = "0 -50%";
            break;
          }
        }
        return {
          role: "slider",
          "aria-valuemin": $min,
          "aria-valuemax": $max,
          "aria-valuenow": thumbValue,
          "aria-disabled": disabledAttr($disabled),
          "aria-orientation": $orientation,
          "data-melt-part": "thumb",
          "data-value": thumbValue,
          style: styleToString(style),
          tabindex: $disabled ? -1 : 0
        };
      });
      return result;
    },
    action: (node) => {
      const unsub = addMeltEventListener(node, "keydown", (event) => {
        if (disabled.get())
          return;
        const target = event.currentTarget;
        if (!isHTMLElement(target))
          return;
        const thumbs2 = getAllThumbs();
        if (!(thumbs2 == null ? void 0 : thumbs2.length))
          return;
        const index = thumbs2.indexOf(target);
        currentThumbIndex.set(index);
        if (![
          kbd.ARROW_LEFT,
          kbd.ARROW_RIGHT,
          kbd.ARROW_UP,
          kbd.ARROW_DOWN,
          kbd.HOME,
          kbd.END
        ].includes(event.key)) {
          return;
        }
        event.preventDefault();
        const $min = min2.get();
        const $max = max2.get();
        const $step = step.get();
        const $value = value.get();
        const $orientation = orientation.get();
        const $direction = direction.get();
        const thumbValue = $value[index];
        switch (event.key) {
          case kbd.HOME: {
            updatePosition($min, index);
            break;
          }
          case kbd.END: {
            updatePosition($max, index);
            break;
          }
          case kbd.ARROW_LEFT: {
            if ($orientation !== "horizontal")
              break;
            if (event.metaKey) {
              const newValue = $direction === "rl" ? $max : $min;
              updatePosition(newValue, index);
            } else if ($direction === "rl" && thumbValue < $max) {
              updatePosition(thumbValue + $step, index);
            } else if ($direction === "lr" && thumbValue > $min) {
              updatePosition(thumbValue - $step, index);
            }
            break;
          }
          case kbd.ARROW_RIGHT: {
            if ($orientation !== "horizontal")
              break;
            if (event.metaKey) {
              const newValue = $direction === "rl" ? $min : $max;
              updatePosition(newValue, index);
            } else if ($direction === "rl" && thumbValue > $min) {
              updatePosition(thumbValue - $step, index);
            } else if ($direction === "lr" && thumbValue < $max) {
              updatePosition(thumbValue + $step, index);
            }
            break;
          }
          case kbd.ARROW_UP: {
            if (event.metaKey) {
              const newValue = $direction === "tb" ? $min : $max;
              updatePosition(newValue, index);
            } else if ($direction === "tb" && thumbValue > $min) {
              updatePosition(thumbValue - $step, index);
            } else if ($direction !== "tb" && thumbValue < $max) {
              updatePosition(thumbValue + $step, index);
            }
            break;
          }
          case kbd.ARROW_DOWN: {
            if (event.metaKey) {
              const newValue = $direction === "tb" ? $max : $min;
              updatePosition(newValue, index);
            } else if ($direction === "tb" && thumbValue < $max) {
              updatePosition(thumbValue + $step, index);
            } else if ($direction !== "tb" && thumbValue > $min) {
              updatePosition(thumbValue - $step, index);
            }
            break;
          }
        }
      });
      return {
        destroy: unsub
      };
    }
  });
  const ticks = makeElementArray(name18("tick"), {
    stores: [value, min2, max2, step, direction],
    returned: ([$value, $min, $max, $step, $direction]) => {
      const difference = $max - $min;
      let count = Math.ceil(difference / $step);
      if (difference % $step == 0) {
        count++;
      }
      return Array.from({ length: count }, (_, i) => {
        const tickPosition = `${i * ($step / ($max - $min)) * 100}%`;
        const isFirst = i === 0;
        const isLast = i === count - 1;
        const offsetPercentage = isFirst ? 0 : isLast ? -100 : -50;
        const style = {
          position: "absolute"
        };
        switch ($direction) {
          case "lr": {
            style.left = tickPosition;
            style.translate = `${offsetPercentage}% 0`;
            break;
          }
          case "rl": {
            style.right = tickPosition;
            style.translate = `${-offsetPercentage}% 0`;
            break;
          }
          case "bt": {
            style.bottom = tickPosition;
            style.translate = `0 ${-offsetPercentage}%`;
            break;
          }
          case "tb": {
            style.top = tickPosition;
            style.translate = `0 ${offsetPercentage}%`;
            break;
          }
        }
        const tickValue = $min + i * $step;
        const bounded = $value.length === 1 ? tickValue <= $value[0] : $value[0] <= tickValue && tickValue <= $value[$value.length - 1];
        return {
          "data-bounded": bounded ? true : void 0,
          "data-value": tickValue,
          style: styleToString(style)
        };
      });
    }
  });
  effect([root, min2, max2, disabled, orientation, direction, step], ([$root, $min, $max, $disabled, $orientation, $direction, $step]) => {
    if (!isBrowser || $disabled)
      return;
    const applyPosition = (clientXY, activeThumbIdx, start, end) => {
      const percent = (clientXY - start) / (end - start);
      const val = percent * ($max - $min) + $min;
      if (val < $min) {
        updatePosition($min, activeThumbIdx);
      } else if (val > $max) {
        updatePosition($max, activeThumbIdx);
      } else {
        const step2 = $step;
        const min3 = $min;
        const currentStep = Math.floor((val - min3) / step2);
        const midpointOfCurrentStep = min3 + currentStep * step2 + step2 / 2;
        const midpointOfNextStep = min3 + (currentStep + 1) * step2 + step2 / 2;
        const newValue = val >= midpointOfCurrentStep && val < midpointOfNextStep ? (currentStep + 1) * step2 + min3 : currentStep * step2 + min3;
        if (newValue <= $max) {
          updatePosition(newValue, activeThumbIdx);
        }
      }
    };
    const getClosestThumb = (e) => {
      const thumbs2 = getAllThumbs();
      if (!thumbs2)
        return;
      thumbs2.forEach((thumb2) => thumb2.blur());
      const distances = thumbs2.map((thumb2) => {
        if ($orientation === "horizontal") {
          const { left, right } = thumb2.getBoundingClientRect();
          return Math.abs(e.clientX - (left + right) / 2);
        } else {
          const { top, bottom } = thumb2.getBoundingClientRect();
          return Math.abs(e.clientY - (top + bottom) / 2);
        }
      });
      const thumb = thumbs2[distances.indexOf(Math.min(...distances))];
      const index = thumbs2.indexOf(thumb);
      return { thumb, index };
    };
    const pointerMove = (e) => {
      if (!isActive.get())
        return;
      e.preventDefault();
      e.stopPropagation();
      const sliderEl = getElementByMeltId($root["data-melt-id"]);
      const closestThumb = activeThumb.get();
      if (!sliderEl || !closestThumb)
        return;
      closestThumb.thumb.focus();
      const { left, right, top, bottom } = sliderEl.getBoundingClientRect();
      switch ($direction) {
        case "lr": {
          applyPosition(e.clientX, closestThumb.index, left, right);
          break;
        }
        case "rl": {
          applyPosition(e.clientX, closestThumb.index, right, left);
          break;
        }
        case "bt": {
          applyPosition(e.clientY, closestThumb.index, bottom, top);
          break;
        }
        case "tb": {
          applyPosition(e.clientY, closestThumb.index, top, bottom);
          break;
        }
      }
    };
    const pointerDown = (e) => {
      if (e.button !== 0)
        return;
      const sliderEl = getElementByMeltId($root["data-melt-id"]);
      const closestThumb = getClosestThumb(e);
      if (!closestThumb || !sliderEl)
        return;
      const target = e.target;
      if (!isHTMLElement(target) || !sliderEl.contains(target)) {
        return;
      }
      e.preventDefault();
      activeThumb.set(closestThumb);
      closestThumb.thumb.focus();
      isActive.set(true);
      pointerMove(e);
    };
    const pointerUp = () => {
      isActive.set(false);
    };
    const unsub = executeCallbacks(addEventListener(document, "pointerdown", pointerDown), addEventListener(document, "pointerup", pointerUp), addEventListener(document, "pointerleave", pointerUp), addEventListener(document, "pointermove", pointerMove));
    return () => {
      unsub();
    };
  });
  effect([step, min2, max2, value], function fixValue([$step, $min, $max, $value]) {
    const isValidValue = (v) => {
      const snappedValue = snapValueToStep(v, $min, $max, $step);
      return snappedValue === v;
    };
    const gcv = (v) => {
      return snapValueToStep(v, $min, $max, $step);
    };
    if ($value.some((v) => !isValidValue(v))) {
      value.update((prev2) => {
        return prev2.map(gcv);
      });
    }
  });
  return {
    elements: {
      root,
      thumbs,
      range,
      ticks
    },
    states: {
      value
    },
    options
  };
};

// node_modules/@melt-ui/svelte/dist/builders/switch/create.js
var defaults28 = {
  defaultChecked: false,
  disabled: false,
  required: false,
  name: "",
  value: ""
};
var { name: name19 } = createElHelpers("switch");
function createSwitch(props) {
  const propsWithDefaults = { ...defaults28, ...props };
  const options = toWritableStores(omit(propsWithDefaults, "checked"));
  const { disabled, required, name: nameStore, value } = options;
  const checkedWritable = propsWithDefaults.checked ?? writable(propsWithDefaults.defaultChecked);
  const checked = overridable(checkedWritable, propsWithDefaults == null ? void 0 : propsWithDefaults.onCheckedChange);
  function toggleSwitch() {
    if (disabled.get())
      return;
    checked.update((prev2) => !prev2);
  }
  const root = makeElement(name19(), {
    stores: [checked, disabled, required],
    returned: ([$checked, $disabled, $required]) => {
      return {
        "data-disabled": disabledAttr($disabled),
        disabled: disabledAttr($disabled),
        "data-state": $checked ? "checked" : "unchecked",
        type: "button",
        role: "switch",
        "aria-checked": $checked ? "true" : "false",
        "aria-required": $required ? "true" : void 0
      };
    },
    action(node) {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        toggleSwitch();
      }), addMeltEventListener(node, "keydown", (e) => {
        if (e.key !== kbd.ENTER && e.key !== kbd.SPACE)
          return;
        e.preventDefault();
        toggleSwitch();
      }));
      return {
        destroy: unsub
      };
    }
  });
  const input = makeElement(name19("input"), {
    stores: [checked, nameStore, required, disabled, value],
    returned: ([$checked, $name, $required, $disabled, $value]) => {
      return {
        type: "checkbox",
        "aria-hidden": true,
        hidden: true,
        tabindex: -1,
        name: $name,
        value: $value,
        checked: $checked,
        required: $required,
        disabled: disabledAttr($disabled),
        style: styleToString({
          position: "absolute",
          opacity: 0,
          "pointer-events": "none",
          margin: 0,
          transform: "translateX(-100%)"
        })
      };
    }
  });
  return {
    elements: {
      root,
      input
    },
    states: {
      checked
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/tabs/create.js
var defaults29 = {
  orientation: "horizontal",
  activateOnFocus: true,
  loop: true,
  autoSet: true
};
var { name: name20, selector: selector6 } = createElHelpers("tabs");
function createTabs(props) {
  const withDefaults = { ...defaults29, ...props };
  const options = toWritableStores(omit(withDefaults, "defaultValue", "value", "onValueChange", "autoSet"));
  const { orientation, activateOnFocus, loop } = options;
  const valueWritable = withDefaults.value ?? writable(withDefaults.defaultValue);
  const value = overridable(valueWritable, withDefaults == null ? void 0 : withDefaults.onValueChange);
  let ssrValue = withDefaults.defaultValue ?? value.get();
  const root = makeElement(name20(), {
    stores: orientation,
    returned: ($orientation) => {
      return {
        "data-orientation": $orientation
      };
    }
  });
  const list = makeElement(name20("list"), {
    stores: orientation,
    returned: ($orientation) => {
      return {
        role: "tablist",
        "aria-orientation": $orientation,
        "data-orientation": $orientation
      };
    }
  });
  const parseTriggerProps = (props2) => {
    if (typeof props2 === "string") {
      return { value: props2 };
    } else {
      return props2;
    }
  };
  const trigger = makeElement(name20("trigger"), {
    stores: [value, orientation],
    returned: ([$value, $orientation]) => {
      return (props2) => {
        const { value: tabValue, disabled } = parseTriggerProps(props2);
        if (!$value && !ssrValue && withDefaults.autoSet) {
          ssrValue = tabValue;
          $value = tabValue;
          value.set(tabValue);
        }
        const sourceOfTruth = isBrowser ? $value : ssrValue;
        const isActive = sourceOfTruth === tabValue;
        return {
          type: "button",
          role: "tab",
          "data-state": isActive ? "active" : "inactive",
          tabindex: isActive ? 0 : -1,
          "data-value": tabValue,
          "data-orientation": $orientation,
          "data-disabled": disabledAttr(disabled),
          disabled: disabledAttr(disabled)
        };
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "focus", () => {
        const disabled = node.dataset.disabled === "true";
        const tabValue = node.dataset.value;
        if (activateOnFocus.get() && !disabled && tabValue !== void 0) {
          value.set(tabValue);
        }
      }), addMeltEventListener(node, "click", (e) => {
        node.focus();
        e.preventDefault();
        const disabled = node.dataset.disabled === "true";
        if (disabled)
          return;
        const tabValue = node.dataset.value;
        node.focus();
        if (tabValue !== void 0) {
          value.set(tabValue);
        }
      }), addMeltEventListener(node, "keydown", (e) => {
        const tabValue = node.dataset.value;
        if (!tabValue)
          return;
        const el = e.currentTarget;
        if (!isHTMLElement(el))
          return;
        const rootEl = el.closest(selector6());
        if (!isHTMLElement(rootEl))
          return;
        const $loop = loop.get();
        const triggers = Array.from(rootEl.querySelectorAll('[role="tab"]')).filter((trigger2) => isHTMLElement(trigger2));
        const enabledTriggers = triggers.filter((el2) => !el2.hasAttribute("data-disabled"));
        const triggerIdx = enabledTriggers.findIndex((el2) => el2 === e.target);
        const dir = getElemDirection(rootEl);
        const { nextKey, prevKey } = getDirectionalKeys(dir, orientation.get());
        if (e.key === nextKey) {
          e.preventDefault();
          const nextEl = next(enabledTriggers, triggerIdx, $loop);
          nextEl.focus();
        } else if (e.key === prevKey) {
          e.preventDefault();
          const prevEl = prev(enabledTriggers, triggerIdx, $loop);
          prevEl.focus();
        } else if (e.key === kbd.ENTER || e.key === kbd.SPACE) {
          e.preventDefault();
          value.set(tabValue);
        } else if (e.key === kbd.HOME) {
          e.preventDefault();
          const firstTrigger = enabledTriggers[0];
          firstTrigger.focus();
        } else if (e.key === kbd.END) {
          e.preventDefault();
          const lastTrigger = last(enabledTriggers);
          lastTrigger.focus();
        }
      }));
      return {
        destroy: unsub
      };
    }
  });
  const content = makeElement(name20("content"), {
    stores: value,
    returned: ($value) => {
      return (tabValue) => {
        return {
          role: "tabpanel",
          // TODO: improve
          "aria-labelledby": tabValue,
          hidden: isBrowser ? $value === tabValue ? void 0 : true : ssrValue === tabValue ? void 0 : true,
          tabindex: 0
        };
      };
    }
  });
  return {
    elements: {
      root,
      list,
      trigger,
      content
    },
    states: {
      value
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/tags-input/create.js
var { name: name21, attribute, selector: selector7 } = createElHelpers("tags-input");

// node_modules/@melt-ui/svelte/dist/builders/toast/create.js
var { name: name22 } = createElHelpers("toast");

// node_modules/@melt-ui/svelte/dist/builders/toggle/create.js
var defaults30 = {
  defaultPressed: false,
  disabled: false
};
function createToggle(props) {
  const withDefaults = { ...defaults30, ...props };
  const options = toWritableStores(omit(withDefaults, "pressed"));
  const { disabled } = options;
  const pressedWritable = withDefaults.pressed ?? writable(withDefaults.defaultPressed);
  const pressed = overridable(pressedWritable, withDefaults == null ? void 0 : withDefaults.onPressedChange);
  function handleToggle() {
    const $disabled = disabled.get();
    if ($disabled)
      return;
    pressed.update((v) => !v);
  }
  const root = makeElement("toggle", {
    stores: [pressed, disabled],
    returned: ([$pressed, $disabled]) => {
      return {
        "data-disabled": disabledAttr($disabled),
        disabled: disabledAttr($disabled),
        "data-state": $pressed ? "on" : "off",
        "aria-pressed": $pressed,
        type: "button"
      };
    },
    action: (node) => {
      const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        handleToggle();
      }), addMeltEventListener(node, "keydown", (e) => {
        if (e.key !== kbd.ENTER && e.key !== kbd.SPACE)
          return;
        e.preventDefault();
        handleToggle();
      }));
      return {
        destroy: unsub
      };
    }
  });
  return {
    elements: {
      root
    },
    states: {
      pressed
    },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/toggle-group/create.js
var defaults31 = {
  type: "single",
  orientation: "horizontal",
  loop: true,
  rovingFocus: true,
  disabled: false,
  defaultValue: ""
};
var { name: name23, selector: selector8 } = createElHelpers("toggle-group");
var createToggleGroup = (props) => {
  const withDefaults = { ...defaults31, ...props };
  const options = toWritableStores(omit(withDefaults, "value"));
  const { type, orientation, loop, rovingFocus, disabled } = options;
  const defaultValue = withDefaults.defaultValue ? withDefaults.defaultValue : withDefaults.type === "single" ? void 0 : [];
  const valueWritable = withDefaults.value ?? writable(defaultValue);
  const value = overridable(valueWritable, withDefaults == null ? void 0 : withDefaults.onValueChange);
  const root = makeElement(name23(), {
    stores: orientation,
    returned: ($orientation) => {
      return {
        role: "group",
        "data-orientation": $orientation
      };
    }
  });
  const item = makeElement(name23("item"), {
    stores: [value, disabled, orientation, type],
    returned: ([$value, $disabled, $orientation, $type]) => {
      return (props2) => {
        const itemValue = typeof props2 === "string" ? props2 : props2.value;
        const argDisabled = typeof props2 === "string" ? false : !!props2.disabled;
        const disabled2 = $disabled || argDisabled;
        const pressed = Array.isArray($value) ? $value.includes(itemValue) : $value === itemValue;
        const isSingle = $type === "single";
        const isMultiple = $type === "multiple" || $type === void 0;
        return {
          disabled: disabledAttr(disabled2),
          pressed,
          "data-orientation": $orientation,
          "data-disabled": disabledAttr(disabled2),
          "data-state": pressed ? "on" : "off",
          "data-value": itemValue,
          "aria-pressed": isMultiple ? pressed : void 0,
          "aria-checked": isSingle ? pressed : void 0,
          type: "button",
          role: isSingle ? "radio" : void 0,
          tabindex: pressed ? 0 : -1
        };
      };
    },
    action: (node) => {
      let unsub = noop2;
      const parentGroup = node.closest(selector8());
      if (!isHTMLElement(parentGroup))
        return {};
      const items = Array.from(parentGroup.querySelectorAll(selector8("item")));
      const $value = value.get();
      const anyPressed = Array.isArray($value) ? $value.length > 0 : $value ? true : false;
      if (!anyPressed && items[0] === node) {
        node.tabIndex = 0;
      }
      function getNodeProps() {
        const itemValue = node.dataset.value;
        const disabled2 = node.dataset.disabled === "true";
        return { value: itemValue, disabled: disabled2 };
      }
      function handleValueUpdate() {
        const { value: itemValue, disabled: disabled2 } = getNodeProps();
        if (itemValue === void 0 || disabled2)
          return;
        value.update(($value2) => {
          if (Array.isArray($value2)) {
            if ($value2.includes(itemValue)) {
              return $value2.filter((i) => i !== itemValue);
            }
            return [...$value2, itemValue];
          }
          return $value2 === itemValue ? void 0 : itemValue;
        });
      }
      unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
        handleValueUpdate();
      }), addMeltEventListener(node, "keydown", (e) => {
        if (e.key === kbd.SPACE || e.key === kbd.ENTER) {
          e.preventDefault();
          handleValueUpdate();
          return;
        }
        if (!rovingFocus.get())
          return;
        const el = e.currentTarget;
        if (!isHTMLElement(el))
          return;
        const root2 = el.closest(selector8());
        if (!isHTMLElement(root2))
          return;
        const items2 = Array.from(root2.querySelectorAll(selector8("item") + ":not([data-disabled])")).filter((item2) => isHTMLElement(item2));
        const currentIndex = items2.indexOf(el);
        const dir = getElemDirection(el);
        const $orientation = orientation.get();
        const nextKey = {
          horizontal: dir === "rtl" ? kbd.ARROW_LEFT : kbd.ARROW_RIGHT,
          vertical: kbd.ARROW_DOWN
        }[$orientation ?? "horizontal"];
        const prevKey = {
          horizontal: dir === "rtl" ? kbd.ARROW_RIGHT : kbd.ARROW_LEFT,
          vertical: kbd.ARROW_UP
        }[$orientation ?? "horizontal"];
        const $loop = loop.get();
        if (e.key === nextKey) {
          e.preventDefault();
          const nextIndex = currentIndex + 1;
          if (nextIndex >= items2.length && $loop) {
            handleRovingFocus(items2[0]);
          } else {
            handleRovingFocus(items2[nextIndex]);
          }
        } else if (e.key === prevKey) {
          e.preventDefault();
          const prevIndex = currentIndex - 1;
          if (prevIndex < 0 && $loop) {
            handleRovingFocus(items2[items2.length - 1]);
          } else {
            handleRovingFocus(items2[prevIndex]);
          }
        } else if (e.key === kbd.HOME) {
          e.preventDefault();
          handleRovingFocus(items2[0]);
        } else if (e.key === kbd.END) {
          e.preventDefault();
          handleRovingFocus(items2[items2.length - 1]);
        }
      }));
      return {
        destroy: unsub
      };
    }
  });
  const isPressed = derived(value, ($value) => {
    return (itemValue) => {
      return Array.isArray($value) ? $value.includes(itemValue) : $value === itemValue;
    };
  });
  return {
    elements: {
      root,
      item
    },
    states: {
      value
    },
    helpers: {
      isPressed
    },
    options
  };
};

// node_modules/@melt-ui/svelte/dist/builders/toolbar/create.js
var defaults32 = {
  loop: true,
  orientation: "horizontal"
};
var { name: name24, selector: selector9 } = createElHelpers("toolbar");
var createToolbar = (props) => {
  const withDefaults = { ...defaults32, ...props };
  const options = toWritableStores(withDefaults);
  const { loop, orientation } = options;
  const root = makeElement(name24(), {
    stores: orientation,
    returned: ($orientation) => {
      return {
        role: "toolbar",
        "data-orientation": $orientation
      };
    }
  });
  const button = makeElement(name24("button"), {
    returned: () => ({
      role: "button",
      type: "button"
    }),
    action: (node) => {
      setNodeTabIndex(node);
      const unsub = addMeltEventListener(node, "keydown", handleKeyDown);
      return {
        destroy: unsub
      };
    }
  });
  const link = makeElement(name24("link"), {
    returned: () => ({
      role: "link"
    }),
    action: (node) => {
      setNodeTabIndex(node);
      const unsub = addMeltEventListener(node, "keydown", handleKeyDown);
      return {
        destroy: unsub
      };
    }
  });
  const separator = makeElement(name24("separator"), {
    stores: orientation,
    returned: ($orientation) => {
      return {
        role: "separator",
        "data-orientation": $orientation === "horizontal" ? "vertical" : "horizontal",
        "aria-orientation": $orientation === "horizontal" ? "vertical" : "horizontal"
      };
    }
  });
  const groupDefaults = {
    type: "single",
    disabled: false
  };
  const createToolbarGroup = (props2) => {
    const groupWithDefaults = { ...groupDefaults, ...props2 };
    const options2 = toWritableStores(groupWithDefaults);
    const { type, disabled } = options2;
    const defaultValue = groupWithDefaults.defaultValue ? groupWithDefaults.defaultValue : groupWithDefaults.type === "single" ? void 0 : [];
    const valueWritable = groupWithDefaults.value ?? writable(defaultValue);
    const value = overridable(valueWritable, groupWithDefaults == null ? void 0 : groupWithDefaults.onValueChange);
    const { name: name27 } = createElHelpers("toolbar-group");
    const group = makeElement(name27(), {
      stores: orientation,
      returned: ($orientation) => {
        return {
          role: "group",
          "data-orientation": $orientation
        };
      }
    });
    const item = makeElement(name27("item"), {
      stores: [disabled, type, value, orientation],
      returned: ([$disabled, $type, $value, $orientation]) => {
        return (props3) => {
          const itemValue = typeof props3 === "string" ? props3 : props3.value;
          const argDisabled = typeof props3 === "string" ? false : !!props3.disabled;
          const disabled2 = $disabled || argDisabled;
          const pressed = Array.isArray($value) ? $value.includes(itemValue) : $value === itemValue;
          const isSingle = $type === "single";
          const isMultiple = $type === "multiple";
          return {
            disabled: disabledAttr(disabled2),
            pressed,
            "data-orientation": $orientation,
            "data-disabled": disabledAttr(disabled2),
            "data-value": itemValue,
            "data-state": pressed ? "on" : "off",
            "aria-checked": isSingle ? pressed : void 0,
            "aria-pressed": isMultiple ? pressed : void 0,
            type: "button",
            role: isSingle ? "radio" : void 0,
            "data-melt-toolbar-item": ""
          };
        };
      },
      action: (node) => {
        setNodeTabIndex(node);
        function getNodeProps() {
          const itemValue = node.dataset.value;
          const disabled2 = node.dataset.disabled === "true";
          return { value: itemValue, disabled: disabled2 };
        }
        function handleValueUpdate() {
          const { value: itemValue, disabled: disabled2 } = getNodeProps();
          if (itemValue === void 0 || disabled2)
            return;
          value.update(($value) => {
            if (Array.isArray($value)) {
              if ($value.includes(itemValue)) {
                return $value.filter((i) => i !== itemValue);
              }
              $value.push(itemValue);
              return $value;
            }
            return $value === itemValue ? void 0 : itemValue;
          });
        }
        const unsub = executeCallbacks(addMeltEventListener(node, "click", () => {
          handleValueUpdate();
        }), addMeltEventListener(node, "keydown", (e) => {
          if (e.key === kbd.ENTER || e.key === kbd.SPACE) {
            e.preventDefault();
            handleValueUpdate();
            return;
          }
          handleKeyDown(e);
        }));
        return {
          destroy: unsub
        };
      }
    });
    const isPressed = derived(value, ($value) => {
      return (itemValue) => {
        return Array.isArray($value) ? $value.includes(itemValue) : $value === itemValue;
      };
    });
    return {
      elements: {
        group,
        item
      },
      states: {
        value
      },
      helpers: {
        isPressed
      },
      options: options2
    };
  };
  function handleKeyDown(e) {
    const $orientation = orientation.get();
    const $loop = loop.get();
    const dir = "ltr";
    const nextKey = {
      horizontal: dir === "rtl" ? kbd.ARROW_LEFT : kbd.ARROW_RIGHT,
      vertical: kbd.ARROW_DOWN
    }[$orientation ?? "horizontal"];
    const prevKey = {
      horizontal: dir === "rtl" ? kbd.ARROW_RIGHT : kbd.ARROW_LEFT,
      vertical: kbd.ARROW_UP
    }[$orientation ?? "horizontal"];
    const el = e.currentTarget;
    if (!isHTMLElement(el))
      return;
    const root2 = el.closest("[data-melt-toolbar]");
    if (!isHTMLElement(root2))
      return;
    const items = getToolbarItems(root2);
    const currentIndex = items.indexOf(el);
    if (e.key === nextKey) {
      e.preventDefault();
      const nextIndex = currentIndex + 1;
      if (nextIndex >= items.length && $loop) {
        handleRovingFocus(items[0]);
      } else {
        handleRovingFocus(items[nextIndex]);
      }
    } else if (e.key === prevKey) {
      e.preventDefault();
      const prevIndex = currentIndex - 1;
      if (prevIndex < 0 && $loop) {
        handleRovingFocus(items[items.length - 1]);
      } else {
        handleRovingFocus(items[prevIndex]);
      }
    } else if (e.key === kbd.HOME) {
      e.preventDefault();
      handleRovingFocus(items[0]);
    } else if (e.key === kbd.END) {
      e.preventDefault();
      handleRovingFocus(items[items.length - 1]);
    }
  }
  return {
    elements: {
      root,
      button,
      separator,
      link
    },
    builders: {
      createToolbarGroup
    },
    options
  };
};
function setNodeTabIndex(node) {
  const parentToolbar = node.closest("[data-melt-toolbar]");
  if (!isHTMLElement(parentToolbar))
    return;
  const items = getToolbarItems(parentToolbar);
  if (items[0] === node) {
    node.tabIndex = 0;
  } else {
    node.tabIndex = -1;
  }
}
function getToolbarItems(element2) {
  return Array.from(element2.querySelectorAll(`${selector9("item")}, ${selector9("button")}, ${selector9("link")}`)).filter((el) => isHTMLElement(el));
}

// node_modules/@melt-ui/svelte/dist/builders/tooltip/create.js
var defaults33 = {
  positioning: {
    placement: "bottom"
  },
  arrowSize: 8,
  defaultOpen: false,
  closeOnPointerDown: true,
  openDelay: 1e3,
  closeDelay: 0,
  forceVisible: false,
  portal: void 0,
  closeOnEscape: true,
  disableHoverableContent: false,
  group: void 0
};
var { name: name25 } = createElHelpers("tooltip");
var groupMap = /* @__PURE__ */ new Map();
var tooltipIdParts = ["trigger", "content"];
function createTooltip(props) {
  const withDefaults = { ...defaults33, ...props };
  const options = toWritableStores(omit(withDefaults, "open", "ids"));
  const { positioning, arrowSize, closeOnPointerDown, openDelay, closeDelay, forceVisible, portal, closeOnEscape, disableHoverableContent, group } = options;
  const openWritable = withDefaults.open ?? writable(withDefaults.defaultOpen);
  const open = overridable(openWritable, withDefaults == null ? void 0 : withDefaults.onOpenChange);
  const openReason = writable(null);
  const ids = toWritableStores({ ...generateIds(tooltipIdParts), ...withDefaults.ids });
  let clickedTrigger = false;
  const getEl = (part) => {
    if (!isBrowser)
      return null;
    return document.getElementById(ids[part].get());
  };
  let openTimeout = null;
  let closeTimeout = null;
  function openTooltip(reason) {
    if (closeTimeout) {
      window.clearTimeout(closeTimeout);
      closeTimeout = null;
    }
    if (!openTimeout) {
      openTimeout = window.setTimeout(() => {
        open.set(true);
        openReason.update((prev2) => prev2 ?? reason);
        openTimeout = null;
      }, openDelay.get());
    }
  }
  function closeTooltip(isBlur) {
    if (openTimeout) {
      window.clearTimeout(openTimeout);
      openTimeout = null;
    }
    if (isBlur && isMouseInTooltipArea) {
      openReason.set("pointer");
      return;
    }
    if (!closeTimeout) {
      closeTimeout = window.setTimeout(() => {
        open.set(false);
        openReason.set(null);
        if (isBlur)
          clickedTrigger = false;
        closeTimeout = null;
      }, closeDelay.get());
    }
  }
  const isVisible = derived([open, forceVisible], ([$open, $forceVisible]) => {
    return $open || $forceVisible;
  });
  const trigger = makeElement(name25("trigger"), {
    stores: [ids.content, ids.trigger, open],
    returned: ([$contentId, $triggerId, $open]) => {
      return {
        "aria-describedby": $contentId,
        id: $triggerId,
        "data-state": $open ? "open" : "closed"
      };
    },
    action: (node) => {
      const keydownHandler = (e) => {
        if (closeOnEscape.get() && e.key === kbd.ESCAPE) {
          if (openTimeout) {
            window.clearTimeout(openTimeout);
            openTimeout = null;
          }
          open.set(false);
        }
      };
      const unsub = executeCallbacks(addMeltEventListener(node, "pointerdown", () => {
        const $closeOnPointerDown = closeOnPointerDown.get();
        if (!$closeOnPointerDown)
          return;
        open.set(false);
        clickedTrigger = true;
        if (openTimeout) {
          window.clearTimeout(openTimeout);
          openTimeout = null;
        }
      }), addMeltEventListener(node, "pointerenter", (e) => {
        if (isTouch(e))
          return;
        openTooltip("pointer");
      }), addMeltEventListener(node, "pointerleave", (e) => {
        if (isTouch(e))
          return;
        if (openTimeout) {
          window.clearTimeout(openTimeout);
          openTimeout = null;
        }
      }), addMeltEventListener(node, "focus", () => {
        if (clickedTrigger)
          return;
        openTooltip("focus");
      }), addMeltEventListener(node, "blur", () => closeTooltip(true)), addMeltEventListener(node, "keydown", keydownHandler), addEventListener(document, "keydown", keydownHandler));
      return {
        destroy: unsub
      };
    }
  });
  const content = makeElement(name25("content"), {
    stores: [isVisible, open, portal, ids.content],
    returned: ([$isVisible, $open, $portal, $contentId]) => {
      return removeUndefined({
        role: "tooltip",
        hidden: $isVisible ? void 0 : true,
        tabindex: -1,
        style: $isVisible ? void 0 : styleToString({ display: "none" }),
        id: $contentId,
        "data-portal": portalAttr($portal),
        "data-state": $open ? "open" : "closed"
      });
    },
    action: (node) => {
      let unsubFloating = noop2;
      let unsubPortal = noop2;
      const unsubDerived = effect([isVisible, positioning, portal], ([$isVisible, $positioning, $portal]) => {
        const triggerEl = getEl("trigger");
        if (!$isVisible || !triggerEl) {
          unsubPortal();
          unsubFloating();
          return;
        }
        tick().then(() => {
          if ($portal === null) {
            unsubPortal();
          } else {
            const portalDest = getPortalDestination(node, $portal);
            if (portalDest) {
              const portalReturn = usePortal(node, portalDest);
              if (portalReturn && portalReturn.destroy) {
                unsubPortal = portalReturn.destroy;
              }
            }
          }
          const floatingReturn = useFloating(triggerEl, node, $positioning);
          unsubFloating = floatingReturn.destroy;
        });
      });
      function handleScroll(e) {
        if (!open.get())
          return;
        const target = e.target;
        if (!isElement(target) && !isDocument(target))
          return;
        const triggerEl = getEl("trigger");
        if (triggerEl && target.contains(triggerEl)) {
          closeTooltip();
        }
      }
      const unsubEvents = executeCallbacks(addMeltEventListener(node, "pointerenter", () => openTooltip("pointer")), addMeltEventListener(node, "pointerdown", () => openTooltip("pointer")), addEventListener(window, "scroll", handleScroll, { capture: true }));
      return {
        destroy() {
          unsubEvents();
          unsubPortal();
          unsubFloating();
          unsubDerived();
        }
      };
    }
  });
  const arrow3 = makeElement(name25("arrow"), {
    stores: arrowSize,
    returned: ($arrowSize) => ({
      "data-arrow": true,
      style: styleToString({
        position: "absolute",
        width: `var(--arrow-size, ${$arrowSize}px)`,
        height: `var(--arrow-size, ${$arrowSize}px)`
      })
    })
  });
  let isMouseInTooltipArea = false;
  effect(open, ($open) => {
    const currentGroup = group.get();
    if (currentGroup === void 0 || currentGroup === false) {
      return;
    }
    if (!$open) {
      if (groupMap.get(currentGroup) === open) {
        groupMap.delete(currentGroup);
      }
      return;
    }
    const currentOpen = groupMap.get(currentGroup);
    currentOpen == null ? void 0 : currentOpen.set(false);
    groupMap.set(currentGroup, open);
  });
  effect([open, openReason], ([$open, $openReason]) => {
    if (!$open || !isBrowser)
      return;
    return executeCallbacks(addEventListener(document, "mousemove", (e) => {
      const contentEl = getEl("content");
      const triggerEl = getEl("trigger");
      if (!contentEl || !triggerEl)
        return;
      const polygonElements = disableHoverableContent.get() ? [triggerEl] : [triggerEl, contentEl];
      const polygon = makeHullFromElements(polygonElements);
      isMouseInTooltipArea = pointInPolygon({
        x: e.clientX,
        y: e.clientY
      }, polygon);
      if ($openReason !== "pointer")
        return;
      if (!isMouseInTooltipArea) {
        closeTooltip();
      }
    }));
  });
  return {
    ids,
    elements: {
      trigger,
      content,
      arrow: arrow3
    },
    states: { open },
    options
  };
}

// node_modules/@melt-ui/svelte/dist/builders/tree/create.js
var { name: name26 } = createElHelpers("tree-view");

// node_modules/bits-ui/dist/internal/attrs.js
function createBitAttrs(bit, parts) {
  const attrs = {};
  parts.forEach((part) => {
    attrs[part] = {
      [`data-${bit}-${part}`]: ""
    };
  });
  return (part) => attrs[part];
}
function disabledAttrs(disabled) {
  return disabled ? { "aria-disabled": "true", "data-disabled": "" } : { "aria-disabled": void 0, "data-disabled": void 0 };
}

// node_modules/bits-ui/dist/internal/events.js
function createDispatcher() {
  const dispatch = createEventDispatcher();
  return (e) => {
    const { originalEvent } = e.detail;
    const { cancelable } = e;
    const type = originalEvent.type;
    const shouldContinue = dispatch(type, { originalEvent, currentTarget: originalEvent.currentTarget }, { cancelable });
    if (!shouldContinue) {
      e.preventDefault();
    }
  };
}

// node_modules/bits-ui/dist/internal/id.js
function generateId2() {
  return nanoid(10);
}

// node_modules/bits-ui/dist/internal/is.js
var isBrowser2 = typeof document !== "undefined";

// node_modules/bits-ui/dist/internal/object.js
function removeUndefined2(obj) {
  const result = {};
  for (const key in obj) {
    const value = obj[key];
    if (value !== void 0) {
      result[key] = value;
    }
  }
  return result;
}

// node_modules/bits-ui/dist/internal/style.js
function styleToString2(style) {
  return Object.keys(style).reduce((str, key) => {
    if (style[key] === void 0)
      return str;
    return str + `${key}:${style[key]};`;
  }, "");
}
function getSrOnlyStyles() {
  return styleToString2({
    position: "absolute",
    width: "1px",
    height: "1px",
    padding: "0",
    margin: "-1px",
    overflow: "hidden",
    clip: "rect(0, 0, 0, 0)",
    whiteSpace: "nowrap",
    borderWidth: "0"
  });
}

// node_modules/bits-ui/dist/internal/updater.js
function getOptionUpdater(options) {
  return function(key, value) {
    if (value === void 0)
      return;
    const store = options[key];
    if (store) {
      store.set(value);
    }
  };
}

// node_modules/bits-ui/dist/internal/focus.js
function handleCalendarInitialFocus(calendar) {
  if (!isBrowser2)
    return;
  const selectedDay = calendar.querySelector("[data-selected]");
  if (selectedDay)
    return focusWithoutScroll(selectedDay);
  const today = calendar.querySelector("[data-today]");
  if (today)
    return focusWithoutScroll(today);
  const firstDay = calendar.querySelector("[data-calendar-date]");
  if (firstDay)
    return focusWithoutScroll(firstDay);
}
function focusWithoutScroll(element2) {
  const scrollPosition = {
    x: window.pageXOffset || document.documentElement.scrollLeft,
    y: window.pageYOffset || document.documentElement.scrollTop
  };
  element2.focus();
  window.scrollTo(scrollPosition.x, scrollPosition.y);
}

// node_modules/bits-ui/dist/bits/accordion/ctx.js
function getAccordionData() {
  const NAME = "accordion";
  const ITEM_NAME = "accordion-item";
  const PARTS = ["root", "content", "header", "item", "trigger"];
  return { NAME, ITEM_NAME, PARTS };
}
function setCtx(props) {
  const initAccordion = createAccordion(removeUndefined2(props));
  const { NAME, PARTS } = getAccordionData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const accordion = {
    ...initAccordion,
    getAttrs: getAttrs2,
    updateOption: getOptionUpdater(initAccordion.options)
  };
  setContext(NAME, accordion);
  return accordion;
}
function getCtx() {
  const { NAME } = getAccordionData();
  return getContext(NAME);
}
function setItem(props) {
  const { ITEM_NAME } = getAccordionData();
  setContext(ITEM_NAME, { ...props });
  const ctx = getCtx();
  return { ...ctx, props };
}
function getItemProps() {
  const { ITEM_NAME } = getAccordionData();
  return getContext(ITEM_NAME);
}
function getContent() {
  const ctx = getCtx();
  const { value: props } = getItemProps();
  return {
    ...ctx,
    props
  };
}
function getTrigger() {
  const ctx = getCtx();
  const { value, disabled } = getItemProps();
  return {
    ...ctx,
    props: { value, disabled }
  };
}

// node_modules/bits-ui/dist/bits/accordion/components/accordion.svelte
var file = "node_modules/bits-ui/dist/bits/accordion/components/accordion.svelte";
var get_default_slot_changes_1 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_1
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file, 51, 1, 1187);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[12](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_1
            ),
            get_default_slot_context_1
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block.name,
    type: "else",
    source: "(51:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes
            ),
            get_default_slot_context
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block.name,
    type: "if",
    source: "(49:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block, create_else_block];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["multiple", "value", "onValueChange", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Accordion", slots, ["default"]);
  let { multiple = false } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { disabled = false } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { value: localValue }, updateOption, getAttrs: getAttrs2 } = setCtx({
    multiple,
    disabled,
    defaultValue: value,
    onValueChange: ({ next: next2 }) => {
      if (Array.isArray(next2)) {
        if (!Array.isArray(value) || !arraysAreEqual(value, next2)) {
          onValueChange == null ? void 0 : onValueChange(next2);
          $$invalidate(5, value = next2);
          return next2;
        }
        return next2;
      }
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(5, value = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(9, $root = value2));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("multiple" in $$new_props) $$invalidate(6, multiple = $$new_props.multiple);
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(7, onValueChange = $$new_props.onValueChange);
    if ("disabled" in $$new_props) $$invalidate(8, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    arraysAreEqual,
    melt,
    setCtx,
    multiple,
    value,
    onValueChange,
    disabled,
    asChild,
    el,
    root,
    localValue,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("multiple" in $$props) $$invalidate(6, multiple = $$new_props.multiple);
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(7, onValueChange = $$new_props.onValueChange);
    if ("disabled" in $$props) $$invalidate(8, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    32) {
      $: value !== void 0 && // eslint-disable-next-line @typescript-eslint/no-explicit-any
      localValue.set(Array.isArray(value) ? [...value] : value);
    }
    if ($$self.$$.dirty & /*multiple*/
    64) {
      $: updateOption("multiple", multiple);
    }
    if ($$self.$$.dirty & /*disabled*/
    256) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*$root*/
    512) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    $$restProps,
    value,
    multiple,
    onValueChange,
    disabled,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Accordion = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance, create_fragment, safe_not_equal, {
      multiple: 6,
      value: 5,
      onValueChange: 7,
      disabled: 8,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Accordion",
      options,
      id: create_fragment.name
    });
  }
  get multiple() {
    throw new Error("<Accordion>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set multiple(value) {
    throw new Error("<Accordion>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Accordion>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Accordion>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Accordion>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Accordion>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Accordion>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Accordion>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Accordion>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Accordion>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Accordion>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Accordion>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var accordion_default = Accordion;

// node_modules/bits-ui/dist/bits/accordion/components/accordion-item.svelte
var file2 = "node_modules/bits-ui/dist/bits/accordion/components/accordion-item.svelte";
var get_default_slot_changes_12 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_12 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes2 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context2 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block2(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_12
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file2, 21, 1, 420);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_12
            ),
            get_default_slot_context_12
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block2.name,
    type: "else",
    source: "(21:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block2(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context2
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes2
            ),
            get_default_slot_context2
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block2.name,
    type: "if",
    source: "(19:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment2(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block2, create_else_block2];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment2.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance2($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["value", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $item;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Accordion_item", slots, ["default"]);
  let { value } = $$props;
  let { disabled = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { item }, props, getAttrs: getAttrs2 } = setItem({ value, disabled });
  validate_store(item, "item");
  component_subscribe($$self, item, (value2) => $$invalidate(7, $item = value2));
  const attrs = getAttrs2("item");
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Accordion_item> was created without expected prop 'value'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(6, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setItem,
    value,
    disabled,
    asChild,
    el,
    item,
    props,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $item
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(6, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$item*/
    128) {
      $: $$invalidate(2, builder = $item(props));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    item,
    $$restProps,
    value,
    disabled,
    $item,
    $$scope,
    slots,
    div_binding
  ];
}
var Accordion_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance2, create_fragment2, safe_not_equal, { value: 5, disabled: 6, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Accordion_item",
      options,
      id: create_fragment2.name
    });
  }
  get value() {
    throw new Error("<Accordion_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Accordion_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Accordion_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Accordion_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Accordion_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Accordion_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Accordion_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Accordion_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var accordion_item_default = Accordion_item;

// node_modules/bits-ui/dist/bits/accordion/components/accordion-header.svelte
var file3 = "node_modules/bits-ui/dist/bits/accordion/components/accordion-header.svelte";
var get_default_slot_changes_13 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_13 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes3 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context3 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block3(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_13
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file3, 19, 1, 379);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[9](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_13
            ),
            get_default_slot_context_13
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block3.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block3(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context3
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes3
            ),
            get_default_slot_context3
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block3.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment3(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block3, create_else_block3];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment3.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance3($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["level", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $header;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Accordion_header", slots, ["default"]);
  let { level = 3 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { heading: header }, getAttrs: getAttrs2 } = getCtx();
  validate_store(header, "header");
  component_subscribe($$self, header, (value) => $$invalidate(6, $header = value));
  const attrs = getAttrs2("header");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("level" in $$new_props) $$invalidate(5, level = $$new_props.level);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx,
    level,
    asChild,
    el,
    header,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $header
  });
  $$self.$inject_state = ($$new_props) => {
    if ("level" in $$props) $$invalidate(5, level = $$new_props.level);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$header, level*/
    96) {
      $: $$invalidate(2, builder = $header(level));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    header,
    $$restProps,
    level,
    $header,
    $$scope,
    slots,
    div_binding
  ];
}
var Accordion_header = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance3, create_fragment3, safe_not_equal, { level: 5, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Accordion_header",
      options,
      id: create_fragment3.name
    });
  }
  get level() {
    throw new Error("<Accordion_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set level(value) {
    throw new Error("<Accordion_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Accordion_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Accordion_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Accordion_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Accordion_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var accordion_header_default = Accordion_header;

// node_modules/bits-ui/dist/bits/accordion/components/accordion-trigger.svelte
var file4 = "node_modules/bits-ui/dist/bits/accordion/components/accordion-trigger.svelte";
var get_default_slot_changes_14 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_14 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes4 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context4 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block4(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_14
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file4, 21, 1, 469);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_14
            ),
            get_default_slot_context_14
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block4.name,
    type: "else",
    source: "(21:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block4(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context4
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes4
            ),
            get_default_slot_context4
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block4.name,
    type: "if",
    source: "(19:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment4(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block4, create_else_block4];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment4.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance4($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Accordion_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, props, getAttrs: getAttrs2 } = getTrigger();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(6, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getTrigger,
    createDispatcher,
    asChild,
    el,
    trigger,
    props,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$trigger*/
    64) {
      $: $$invalidate(2, builder = $trigger(props));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Accordion_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance4, create_fragment4, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Accordion_trigger",
      options,
      id: create_fragment4.name
    });
  }
  get asChild() {
    throw new Error("<Accordion_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Accordion_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Accordion_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Accordion_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var accordion_trigger_default = Accordion_trigger;

// node_modules/bits-ui/dist/bits/accordion/components/accordion-content.svelte
var file5 = "node_modules/bits-ui/dist/bits/accordion/components/accordion-content.svelte";
var get_default_slot_changes_5 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_5 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_4 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_4 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_3 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_3 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_2 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_2 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_15 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_15 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes5 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context5 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_5(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_5
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file5, 48, 1, 1466);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[21](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes_5
            ),
            get_default_slot_context_5
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[21](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_5.name,
    type: "if",
    source: "(48:29) ",
    ctx
  });
  return block;
}
function create_if_block_4(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_4
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file5, 44, 1, 1296);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[20](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_4
            ),
            get_default_slot_context_4
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[20](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_4.name,
    type: "if",
    source: "(44:46) ",
    ctx
  });
  return block;
}
function create_if_block_3(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_3
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file5, 40, 1, 1112);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[19](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_3
            ),
            get_default_slot_context_3
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[19](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_3.name,
    type: "if",
    source: "(40:45) ",
    ctx
  });
  return block;
}
function create_if_block_2(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_2
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file5, 30, 1, 877);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[18](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_2
            ),
            get_default_slot_context_2
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[18](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_2.name,
    type: "if",
    source: "(30:62) ",
    ctx
  });
  return block;
}
function create_if_block_1(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_15
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file5, 26, 1, 673);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[17](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_15
            ),
            get_default_slot_context_15
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[17](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_1.name,
    type: "if",
    source: "(26:43) ",
    ctx
  });
  return block;
}
function create_if_block5(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context5
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes5
            ),
            get_default_slot_context5
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block5.name,
    type: "if",
    source: "(24:0) {#if asChild && $isSelected(props)}",
    ctx
  });
  return block;
}
function create_fragment5(ctx) {
  let show_if;
  let show_if_1;
  let show_if_2;
  let show_if_3;
  let show_if_4;
  let show_if_5;
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block5,
    create_if_block_1,
    create_if_block_2,
    create_if_block_3,
    create_if_block_4,
    create_if_block_5
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (dirty & /*asChild, $isSelected*/
    640) show_if = null;
    if (dirty & /*transition, $isSelected*/
    514) show_if_1 = null;
    if (dirty & /*inTransition, outTransition, $isSelected*/
    552) show_if_2 = null;
    if (dirty & /*inTransition, $isSelected*/
    520) show_if_3 = null;
    if (dirty & /*outTransition, $isSelected*/
    544) show_if_4 = null;
    if (dirty & /*$isSelected*/
    512) show_if_5 = null;
    if (show_if == null) show_if = !!/*asChild*/
    (ctx2[7] && /*$isSelected*/
    ctx2[9](
      /*props*/
      ctx2[12]
    ));
    if (show_if) return 0;
    if (show_if_1 == null) show_if_1 = !!/*transition*/
    (ctx2[1] && /*$isSelected*/
    ctx2[9](
      /*props*/
      ctx2[12]
    ));
    if (show_if_1) return 1;
    if (show_if_2 == null) show_if_2 = !!/*inTransition*/
    (ctx2[3] && /*outTransition*/
    ctx2[5] && /*$isSelected*/
    ctx2[9](
      /*props*/
      ctx2[12]
    ));
    if (show_if_2) return 2;
    if (show_if_3 == null) show_if_3 = !!/*inTransition*/
    (ctx2[3] && /*$isSelected*/
    ctx2[9](
      /*props*/
      ctx2[12]
    ));
    if (show_if_3) return 3;
    if (show_if_4 == null) show_if_4 = !!/*outTransition*/
    (ctx2[5] && /*$isSelected*/
    ctx2[9](
      /*props*/
      ctx2[12]
    ));
    if (show_if_4) return 4;
    if (show_if_5 == null) show_if_5 = !!/*$isSelected*/
    ctx2[9](
      /*props*/
      ctx2[12]
    );
    if (show_if_5) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, -1))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment5.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance5($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let $isSelected;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Accordion_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, helpers: { isSelected }, props, getAttrs: getAttrs2 } = getContent();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(14, $content = value));
  validate_store(isSelected, "isSelected");
  component_subscribe($$self, isSelected, (value) => $$invalidate(9, $isSelected = value));
  const attrs = getAttrs2("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(15, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getContent,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    el,
    content,
    isSelected,
    props,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $content,
    $isSelected
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$content*/
    16384) {
      $: $$invalidate(8, builder = $content(props));
    }
    if ($$self.$$.dirty & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $isSelected,
    content,
    isSelected,
    props,
    $$restProps,
    $content,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Accordion_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance5, create_fragment5, safe_not_equal, {
      transition: 1,
      transitionConfig: 2,
      inTransition: 3,
      inTransitionConfig: 4,
      outTransition: 5,
      outTransitionConfig: 6,
      asChild: 7,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Accordion_content",
      options,
      id: create_fragment5.name
    });
  }
  get transition() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Accordion_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Accordion_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var accordion_content_default = Accordion_content;

// node_modules/bits-ui/dist/bits/alert-dialog/index.js
var alert_dialog_exports = {};
__export(alert_dialog_exports, {
  Action: () => alert_dialog_action_default,
  Cancel: () => alert_dialog_cancel_default,
  Content: () => alert_dialog_content_default,
  Description: () => alert_dialog_description_default,
  Overlay: () => alert_dialog_overlay_default,
  Portal: () => alert_dialog_portal_default,
  Root: () => alert_dialog_default,
  Title: () => alert_dialog_title_default,
  Trigger: () => alert_dialog_trigger_default
});

// node_modules/bits-ui/dist/bits/alert-dialog/ctx.js
function getAlertDialogData() {
  const NAME = "alert-dialog";
  const PARTS = [
    "action",
    "cancel",
    "content",
    "description",
    "overlay",
    "portal",
    "title",
    "trigger"
  ];
  return { NAME, PARTS };
}
function setCtx2(props) {
  const { NAME, PARTS } = getAlertDialogData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const initAlertDialog = createDialog({
    ...removeUndefined2(props),
    role: "alertdialog",
    forceVisible: true
  });
  const alertDialog = {
    ...initAlertDialog,
    getAttrs: getAttrs2,
    updateOption: getOptionUpdater(initAlertDialog.options)
  };
  setContext(NAME, alertDialog);
  return {
    ...alertDialog,
    updateOption: getOptionUpdater(alertDialog.options),
    getAttrs: getAttrs2
  };
}
function getCtx2() {
  const { NAME } = getAlertDialogData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog.svelte
var get_default_slot_changes6 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context6 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment6(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[12].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[11],
    get_default_slot_context6
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        2049)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[11],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[11]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[11],
              dirty,
              get_default_slot_changes6
            ),
            get_default_slot_context6
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment6.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance6($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog", slots, ["default"]);
  let { preventScroll = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { closeOnOutsideClick = false } = $$props;
  let { portal = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { openFocus = void 0 } = $$props;
  let { closeFocus = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { open: localOpen }, updateOption, ids } = setCtx2({
    closeOnEscape,
    preventScroll,
    closeOnOutsideClick,
    portal,
    forceVisible: true,
    defaultOpen: open,
    openFocus,
    closeFocus,
    onOutsideClick,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.content, ids.description, ids.title], ([$contentId, $descriptionId, $titleId]) => ({
    content: $contentId,
    description: $descriptionId,
    title: $titleId
  }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "preventScroll",
    "closeOnEscape",
    "closeOnOutsideClick",
    "portal",
    "open",
    "onOpenChange",
    "openFocus",
    "closeFocus",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Alert_dialog> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("preventScroll" in $$props2) $$invalidate(3, preventScroll = $$props2.preventScroll);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(5, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(6, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(7, onOpenChange = $$props2.onOpenChange);
    if ("openFocus" in $$props2) $$invalidate(8, openFocus = $$props2.openFocus);
    if ("closeFocus" in $$props2) $$invalidate(9, closeFocus = $$props2.closeFocus);
    if ("onOutsideClick" in $$props2) $$invalidate(10, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(11, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx2,
    preventScroll,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    open,
    onOpenChange,
    openFocus,
    closeFocus,
    onOutsideClick,
    localOpen,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("preventScroll" in $$props2) $$invalidate(3, preventScroll = $$props2.preventScroll);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(5, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(6, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(7, onOpenChange = $$props2.onOpenChange);
    if ("openFocus" in $$props2) $$invalidate(8, openFocus = $$props2.openFocus);
    if ("closeFocus" in $$props2) $$invalidate(9, closeFocus = $$props2.closeFocus);
    if ("onOutsideClick" in $$props2) $$invalidate(10, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    8) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    16) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    32) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*portal*/
    64) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*openFocus*/
    256) {
      $: updateOption("openFocus", openFocus);
    }
    if ($$self.$$.dirty & /*closeFocus*/
    512) {
      $: updateOption("closeFocus", closeFocus);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    1024) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    preventScroll,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    onOpenChange,
    openFocus,
    closeFocus,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Alert_dialog = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance6, create_fragment6, safe_not_equal, {
      preventScroll: 3,
      closeOnEscape: 4,
      closeOnOutsideClick: 5,
      portal: 6,
      open: 2,
      onOpenChange: 7,
      openFocus: 8,
      closeFocus: 9,
      onOutsideClick: 10
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog",
      options,
      id: create_fragment6.name
    });
  }
  get preventScroll() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnOutsideClick() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get openFocus() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set openFocus(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeFocus() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeFocus(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Alert_dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Alert_dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_default = Alert_dialog;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-title.svelte
var file6 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-title.svelte";
var get_default_slot_changes_16 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context_16 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
var get_default_slot_changes7 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context7 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
function create_else_block5(ctx) {
  let previous_tag = (
    /*level*/
    ctx[1]
  );
  let svelte_element_anchor;
  let current;
  validate_dynamic_element(
    /*level*/
    ctx[1]
  );
  validate_void_dynamic_element(
    /*level*/
    ctx[1]
  );
  let svelte_element = (
    /*level*/
    ctx[1] && create_dynamic_element(ctx)
  );
  const block = {
    c: function create() {
      if (svelte_element) svelte_element.c();
      svelte_element_anchor = empty();
    },
    l: function claim(nodes) {
      if (svelte_element) svelte_element.l(nodes);
      svelte_element_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (svelte_element) svelte_element.m(target, anchor);
      insert_hydration_dev(target, svelte_element_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*level*/
        ctx2[1]
      ) {
        if (!previous_tag) {
          svelte_element = create_dynamic_element(ctx2);
          previous_tag = /*level*/
          ctx2[1];
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else if (safe_not_equal(
          previous_tag,
          /*level*/
          ctx2[1]
        )) {
          svelte_element.d(1);
          validate_dynamic_element(
            /*level*/
            ctx2[1]
          );
          validate_void_dynamic_element(
            /*level*/
            ctx2[1]
          );
          svelte_element = create_dynamic_element(ctx2);
          previous_tag = /*level*/
          ctx2[1];
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else {
          svelte_element.p(ctx2, dirty);
        }
      } else if (previous_tag) {
        svelte_element.d(1);
        svelte_element = null;
        previous_tag = /*level*/
        ctx2[1];
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(svelte_element, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(svelte_element, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element_anchor);
      }
      if (svelte_element) svelte_element.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block5.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block6(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context7
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes7
            ),
            get_default_slot_context7
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block6.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_dynamic_element(ctx) {
  let svelte_element;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_16
  );
  let svelte_element_levels = [
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[5]
  ];
  let svelte_element_data = {};
  for (let i = 0; i < svelte_element_levels.length; i += 1) {
    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
  }
  const block = {
    c: function create() {
      svelte_element = element(
        /*level*/
        ctx[1]
      );
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      svelte_element = claim_element(
        nodes,
        /*level*/
        (ctx[1] || "null").toUpperCase(),
        {}
      );
      var svelte_element_nodes = children(svelte_element);
      if (default_slot) default_slot.l(svelte_element_nodes);
      svelte_element_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_dynamic_element_data(
        /*level*/
        ctx[1]
      )(svelte_element, svelte_element_data);
      add_location(svelte_element, file6, 25, 1, 436);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, svelte_element, anchor);
      if (default_slot) {
        default_slot.m(svelte_element, null);
      }
      ctx[10](svelte_element);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[3].action(svelte_element));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_16
            ),
            get_default_slot_context_16
          );
        }
      }
      set_dynamic_element_data(
        /*level*/
        ctx2[1]
      )(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_dynamic_element.name,
    type: "child_dynamic_element",
    source: "(26:1) <svelte:element this={level} bind:this={el} {...builder} use:builder.action {...$$restProps}>",
    ctx
  });
  return block;
}
function create_fragment7(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block6, create_else_block5];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment7.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance7($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["level", "asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $title;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_title", slots, ["default"]);
  let { level = "h2" } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { title }, ids, getAttrs: getAttrs2 } = getCtx2();
  validate_store(title, "title");
  component_subscribe($$self, title, (value) => $$invalidate(7, $title = value));
  const attrs = getAttrs2("title");
  function svelte_element_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("level" in $$new_props) $$invalidate(1, level = $$new_props.level);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx2,
    level,
    asChild,
    id,
    el,
    title,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $title
  });
  $$self.$inject_state = ($$new_props) => {
    if ("level" in $$props) $$invalidate(1, level = $$new_props.level);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.title.set(id);
      }
    }
    if ($$self.$$.dirty & /*$title*/
    128) {
      $: $$invalidate(3, builder = $title);
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    level,
    asChild,
    builder,
    title,
    $$restProps,
    id,
    $title,
    $$scope,
    slots,
    svelte_element_binding
  ];
}
var Alert_dialog_title = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance7, create_fragment7, safe_not_equal, { level: 1, asChild: 2, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_title",
      options,
      id: create_fragment7.name
    });
  }
  get level() {
    throw new Error("<Alert_dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set level(value) {
    throw new Error("<Alert_dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Alert_dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Alert_dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Alert_dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_title_default = Alert_dialog_title;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-action.svelte
var file7 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-action.svelte";
var get_default_slot_changes_17 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_17 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes8 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context8 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block6(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_17
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file7, 20, 1, 440);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_17
            ),
            get_default_slot_context_17
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block6.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block7(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context8
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes8
            ),
            get_default_slot_context8
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block7.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment8(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block7, create_else_block6];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment8.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance8($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $close;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_action", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { close }, getAttrs: getAttrs2 } = getCtx2();
  validate_store(close, "close");
  component_subscribe($$self, close, (value) => $$invalidate(6, $close = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("action");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    createDispatcher,
    getCtx: getCtx2,
    asChild,
    el,
    close,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $close
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$close*/
    64) {
      $: $$invalidate(2, builder = $close);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    close,
    dispatch,
    $$restProps,
    $close,
    $$scope,
    slots,
    button_binding
  ];
}
var Alert_dialog_action = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance8, create_fragment8, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_action",
      options,
      id: create_fragment8.name
    });
  }
  get asChild() {
    throw new Error("<Alert_dialog_action>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_action>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_action>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_action>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_action_default = Alert_dialog_action;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-cancel.svelte
var file8 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-cancel.svelte";
var get_default_slot_changes_18 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_18 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes9 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context9 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block7(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_18
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file8, 20, 1, 440);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_18
            ),
            get_default_slot_context_18
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block7.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block8(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context9
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes9
            ),
            get_default_slot_context9
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block8.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment9(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block8, create_else_block7];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment9.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance9($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $close;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_cancel", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { close }, getAttrs: getAttrs2 } = getCtx2();
  validate_store(close, "close");
  component_subscribe($$self, close, (value) => $$invalidate(6, $close = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("cancel");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx2,
    createDispatcher,
    asChild,
    el,
    close,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $close
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$close*/
    64) {
      $: $$invalidate(2, builder = $close);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    close,
    dispatch,
    $$restProps,
    $close,
    $$scope,
    slots,
    button_binding
  ];
}
var Alert_dialog_cancel = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance9, create_fragment9, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_cancel",
      options,
      id: create_fragment9.name
    });
  }
  get asChild() {
    throw new Error("<Alert_dialog_cancel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_cancel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_cancel>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_cancel>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_cancel_default = Alert_dialog_cancel;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-portal.svelte
var file9 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-portal.svelte";
var get_default_slot_changes_19 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_19 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes10 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context10 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block8(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_19
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file9, 18, 1, 347);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_19
            ),
            get_default_slot_context_19
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block8.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block9(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context10
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes10
            ),
            get_default_slot_context10
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block9.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment10(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block9, create_else_block8];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment10.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance10($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $portalled;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_portal", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { portalled }, getAttrs: getAttrs2 } = getCtx2();
  validate_store(portalled, "portalled");
  component_subscribe($$self, portalled, (value) => $$invalidate(5, $portalled = value));
  const attrs = getAttrs2("portal");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx2,
    asChild,
    el,
    portalled,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $portalled
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$portalled*/
    32) {
      $: $$invalidate(2, builder = $portalled);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    portalled,
    $$restProps,
    $portalled,
    $$scope,
    slots,
    div_binding
  ];
}
var Alert_dialog_portal = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance10, create_fragment10, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_portal",
      options,
      id: create_fragment10.name
    });
  }
  get asChild() {
    throw new Error("<Alert_dialog_portal>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_portal>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_portal>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_portal>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_portal_default = Alert_dialog_portal;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-content.svelte
var file10 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-content.svelte";
var get_default_slot_changes_52 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_52 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_42 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_42 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_32 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_32 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_22 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_22 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_110 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_110 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes11 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context11 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_52(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_52
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file10, 96, 1, 1906);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[56](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_4*/
            ctx[45],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_4*/
            ctx[46],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_4*/
            ctx[47],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_4*/
            ctx[48],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_4*/
            ctx[49],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_4*/
            ctx[50],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_4*/
            ctx[51],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes_52
            ),
            get_default_slot_context_52
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[56](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_52.name,
    type: "if",
    source: "(96:16) ",
    ctx
  });
  return block;
}
function create_if_block_42(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_42
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file10, 80, 1, 1628);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[55](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_3*/
            ctx[38],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_3*/
            ctx[39],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_3*/
            ctx[40],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_3*/
            ctx[41],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_3*/
            ctx[42],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_3*/
            ctx[43],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_3*/
            ctx[44],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_42
            ),
            get_default_slot_context_42
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[55](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_42.name,
    type: "if",
    source: "(80:33) ",
    ctx
  });
  return block;
}
function create_if_block_32(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_32
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file10, 64, 1, 1336);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[54](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_2*/
            ctx[31],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_2*/
            ctx[32],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_2*/
            ctx[33],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_2*/
            ctx[34],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_2*/
            ctx[35],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_2*/
            ctx[36],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_2*/
            ctx[37],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_32
            ),
            get_default_slot_context_32
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[54](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_32.name,
    type: "if",
    source: "(64:32) ",
    ctx
  });
  return block;
}
function create_if_block_22(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_22
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file10, 47, 1, 1003);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[53](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_1*/
            ctx[24],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_1*/
            ctx[25],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_1*/
            ctx[26],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_1*/
            ctx[27],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_1*/
            ctx[28],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_1*/
            ctx[29],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_1*/
            ctx[30],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_22
            ),
            get_default_slot_context_22
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[53](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_22.name,
    type: "if",
    source: "(47:49) ",
    ctx
  });
  return block;
}
function create_if_block_12(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_110
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file10, 31, 1, 691);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[52](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler*/
            ctx[17],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler*/
            ctx[18],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler*/
            ctx[19],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler*/
            ctx[20],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler*/
            ctx[21],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler*/
            ctx[22],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler*/
            ctx[23],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_110
            ),
            get_default_slot_context_110
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[52](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_12.name,
    type: "if",
    source: "(31:30) ",
    ctx
  });
  return block;
}
function create_if_block10(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context11
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes11
            ),
            get_default_slot_context11
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block10.name,
    type: "if",
    source: "(29:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment11(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block10,
    create_if_block_12,
    create_if_block_22,
    create_if_block_32,
    create_if_block_42,
    create_if_block_52
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment11.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance11($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "id",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { id = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx2();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(14, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getAttrs2("content");
  function pointerdown_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("id" in $$new_props) $$invalidate(13, id = $$new_props.id);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(15, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx2,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    id,
    asChild,
    el,
    content,
    open,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $content,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("id" in $$props) $$invalidate(13, id = $$new_props.id);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    8192) {
      $: if (id) {
        ids.content.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$content*/
    16384) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    $$restProps,
    id,
    $content,
    $$scope,
    slots,
    pointerdown_handler,
    pointermove_handler,
    pointerup_handler,
    touchend_handler,
    touchstart_handler,
    touchcancel_handler,
    touchmove_handler,
    pointerdown_handler_1,
    pointermove_handler_1,
    pointerup_handler_1,
    touchend_handler_1,
    touchstart_handler_1,
    touchcancel_handler_1,
    touchmove_handler_1,
    pointerdown_handler_2,
    pointermove_handler_2,
    pointerup_handler_2,
    touchend_handler_2,
    touchstart_handler_2,
    touchcancel_handler_2,
    touchmove_handler_2,
    pointerdown_handler_3,
    pointermove_handler_3,
    pointerup_handler_3,
    touchend_handler_3,
    touchstart_handler_3,
    touchcancel_handler_3,
    touchmove_handler_3,
    pointerdown_handler_4,
    pointermove_handler_4,
    pointerup_handler_4,
    touchend_handler_4,
    touchstart_handler_4,
    touchcancel_handler_4,
    touchmove_handler_4,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Alert_dialog_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance11,
      create_fragment11,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        id: 13,
        asChild: 7,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_content",
      options,
      id: create_fragment11.name
    });
  }
  get transition() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_content_default = Alert_dialog_content;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-overlay.svelte
var file11 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-overlay.svelte";
var get_default_slot_changes12 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context12 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_53(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file11, 44, 1, 1257);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[20](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[20](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_53.name,
    type: "if",
    source: "(44:16) ",
    ctx
  });
  return block;
}
function create_if_block_43(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file11, 42, 1, 1127);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[19](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[19](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_43.name,
    type: "if",
    source: "(42:33) ",
    ctx
  });
  return block;
}
function create_if_block_33(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file11, 40, 1, 983);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[18](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
    },
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[18](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_33.name,
    type: "if",
    source: "(40:32) ",
    ctx
  });
  return block;
}
function create_if_block_23(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file11, 32, 1, 789);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[17](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[17](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_23.name,
    type: "if",
    source: "(32:49) ",
    ctx
  });
  return block;
}
function create_if_block_13(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file11, 25, 1, 616);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[16](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[16](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_13.name,
    type: "if",
    source: "(25:30) ",
    ctx
  });
  return block;
}
function create_if_block11(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context12
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes12
            ),
            get_default_slot_context12
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block11.name,
    type: "if",
    source: "(23:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment12(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block11,
    create_if_block_13,
    create_if_block_23,
    create_if_block_33,
    create_if_block_43,
    create_if_block_53
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, -1))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment12.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance12($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $overlay;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_overlay", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { overlay }, states: { open }, getAttrs: getAttrs2 } = getCtx2();
  validate_store(overlay, "overlay");
  component_subscribe($$self, overlay, (value) => $$invalidate(13, $overlay = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getAttrs2("overlay");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(14, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx2,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    el,
    overlay,
    open,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $overlay,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$overlay*/
    8192) {
      $: $$invalidate(8, builder = $overlay);
    }
    if ($$self.$$.dirty & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    overlay,
    open,
    $$restProps,
    $overlay,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Alert_dialog_overlay = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance12, create_fragment12, safe_not_equal, {
      transition: 1,
      transitionConfig: 2,
      inTransition: 3,
      inTransitionConfig: 4,
      outTransition: 5,
      outTransitionConfig: 6,
      asChild: 7,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_overlay",
      options,
      id: create_fragment12.name
    });
  }
  get transition() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_overlay_default = Alert_dialog_overlay;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-trigger.svelte
var file12 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-trigger.svelte";
var get_default_slot_changes_111 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_111 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes13 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context13 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block9(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_111
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file12, 20, 1, 445);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_111
            ),
            get_default_slot_context_111
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block9.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block12(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context13
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes13
            ),
            get_default_slot_context13
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block12.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment13(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block12, create_else_block9];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment13.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance13($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, getAttrs: getAttrs2 } = getCtx2();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(6, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx2,
    createDispatcher,
    asChild,
    el,
    trigger,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$trigger*/
    64) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Alert_dialog_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance13, create_fragment13, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_trigger",
      options,
      id: create_fragment13.name
    });
  }
  get asChild() {
    throw new Error("<Alert_dialog_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_trigger_default = Alert_dialog_trigger;

// node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-description.svelte
var file13 = "node_modules/bits-ui/dist/bits/alert-dialog/components/alert-dialog-description.svelte";
var get_default_slot_changes_112 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_112 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes14 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context14 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block10(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_112
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file13, 24, 1, 435);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[9](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_112
            ),
            get_default_slot_context_112
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block10.name,
    type: "else",
    source: "(24:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block13(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context14
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes14
            ),
            get_default_slot_context14
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block13.name,
    type: "if",
    source: "(22:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment14(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block13, create_else_block10];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment14.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance14($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $description;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Alert_dialog_description", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { description }, ids, getAttrs: getAttrs2 } = getCtx2();
  validate_store(description, "description");
  component_subscribe($$self, description, (value) => $$invalidate(6, $description = value));
  const attrs = getAttrs2("description");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx2,
    asChild,
    id,
    el,
    description,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $description
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    32) {
      $: if (id) {
        ids.description.set(id);
      }
    }
    if ($$self.$$.dirty & /*$description*/
    64) {
      $: $$invalidate(2, builder = $description);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    description,
    $$restProps,
    id,
    $description,
    $$scope,
    slots,
    div_binding
  ];
}
var Alert_dialog_description = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance14, create_fragment14, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Alert_dialog_description",
      options,
      id: create_fragment14.name
    });
  }
  get asChild() {
    throw new Error("<Alert_dialog_description>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Alert_dialog_description>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Alert_dialog_description>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Alert_dialog_description>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Alert_dialog_description>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Alert_dialog_description>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var alert_dialog_description_default = Alert_dialog_description;

// node_modules/bits-ui/dist/bits/aspect-ratio/index.js
var aspect_ratio_exports = {};
__export(aspect_ratio_exports, {
  Root: () => aspect_ratio_default
});

// node_modules/bits-ui/dist/bits/aspect-ratio/components/aspect-ratio.svelte
var file14 = "node_modules/bits-ui/dist/bits/aspect-ratio/components/aspect-ratio.svelte";
function create_fragment15(ctx) {
  let div1;
  let div0;
  let style_padding_bottom = `${/*ratio*/
  ctx[1] ? 100 / /*ratio*/
  ctx[1] : 0}%`;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    null
  );
  let div0_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div0_levels.length; i += 1) {
    div_data = assign(div_data, div0_levels[i]);
  }
  const block = {
    c: function create() {
      div1 = element("div");
      div0 = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div1 = claim_element(nodes, "DIV", {});
      var div1_nodes = children(div1);
      div0 = claim_element(div1_nodes, "DIV", {});
      var div0_nodes = children(div0);
      if (default_slot) default_slot.l(div0_nodes);
      div0_nodes.forEach(detach_dev);
      div1_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div0, div_data);
      set_style(div0, "position", `absolute`);
      set_style(div0, "top", `0`);
      set_style(div0, "right", `0`);
      set_style(div0, "bottom", `0`);
      set_style(div0, "left", `0`);
      add_location(div0, file14, 8, 1, 221);
      set_style(div1, "position", `relative`);
      set_style(div1, "width", `100%`);
      set_style(div1, "padding-bottom", style_padding_bottom);
      add_location(div1, file14, 7, 0, 119);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div1, anchor);
      append_hydration_dev(div1, div0);
      if (default_slot) {
        default_slot.m(div0, null);
      }
      ctx[6](div0);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(div0, div_data = get_spread_update(div0_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
      set_style(div0, "position", `absolute`);
      set_style(div0, "top", `0`);
      set_style(div0, "right", `0`);
      set_style(div0, "bottom", `0`);
      set_style(div0, "left", `0`);
      if (dirty & /*ratio*/
      2 && style_padding_bottom !== (style_padding_bottom = `${/*ratio*/
      ctx2[1] ? 100 / /*ratio*/
      ctx2[1] : 0}%`)) {
        set_style(div1, "padding-bottom", style_padding_bottom);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div1);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment15.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance15($$self, $$props, $$invalidate) {
  const omit_props_names = ["ratio", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Aspect_ratio", slots, ["default"]);
  let { ratio = 1 / 1 } = $$props;
  let { el = void 0 } = $$props;
  const attrs = { "data-aspect-ratio-root": "" };
  function div0_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("ratio" in $$new_props) $$invalidate(1, ratio = $$new_props.ratio);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({ ratio, el, attrs });
  $$self.$inject_state = ($$new_props) => {
    if ("ratio" in $$props) $$invalidate(1, ratio = $$new_props.ratio);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, ratio, attrs, $$restProps, $$scope, slots, div0_binding];
}
var Aspect_ratio = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance15, create_fragment15, safe_not_equal, { ratio: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Aspect_ratio",
      options,
      id: create_fragment15.name
    });
  }
  get ratio() {
    throw new Error("<Aspect_ratio>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set ratio(value) {
    throw new Error("<Aspect_ratio>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Aspect_ratio>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Aspect_ratio>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var aspect_ratio_default = Aspect_ratio;

// node_modules/bits-ui/dist/bits/avatar/index.js
var avatar_exports = {};
__export(avatar_exports, {
  Fallback: () => avatar_fallback_default,
  Image: () => avatar_image_default,
  Root: () => avatar_default
});

// node_modules/bits-ui/dist/bits/avatar/ctx.js
function getAvatarData() {
  const NAME = "avatar";
  const PARTS = ["root", "image", "fallback"];
  return {
    NAME,
    PARTS
  };
}
function setCtx3(props) {
  const { NAME, PARTS } = getAvatarData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const avatar = { ...createAvatar(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, avatar);
  return {
    ...avatar,
    updateOption: getOptionUpdater(avatar.options)
  };
}
function getImage(src = "") {
  const { NAME } = getAvatarData();
  const avatar = getContext(NAME);
  if (!src) {
    avatar.options.src.set("");
  } else {
    avatar.options.src.set(src);
  }
  return avatar;
}
function getCtx3() {
  const { NAME } = getAvatarData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/avatar/components/avatar.svelte
var file15 = "node_modules/bits-ui/dist/bits/avatar/components/avatar.svelte";
var get_default_slot_changes_113 = (dirty) => ({});
var get_default_slot_context_113 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes15 = (dirty) => ({});
var get_default_slot_context15 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block11(ctx) {
  let div;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_113
  );
  let div_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file15, 29, 1, 644);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[9](div);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        128)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_113
            ),
            get_default_slot_context_113
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block11.name,
    type: "else",
    source: "(29:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block14(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context15
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        128)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes15
            ),
            get_default_slot_context15
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block14.name,
    type: "if",
    source: "(27:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment16(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block14, create_else_block11];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment16.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance16($$self, $$props, $$invalidate) {
  const omit_props_names = ["delayMs", "loadingStatus", "onLoadingStatusChange", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Avatar", slots, ["default"]);
  let { delayMs = void 0 } = $$props;
  let { loadingStatus = void 0 } = $$props;
  let { onLoadingStatusChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { states: { loadingStatus: localLoadingStatus }, updateOption, getAttrs: getAttrs2 } = setCtx3({
    src: "",
    delayMs,
    onLoadingStatusChange: ({ next: next2 }) => {
      $$invalidate(4, loadingStatus = next2);
      onLoadingStatusChange == null ? void 0 : onLoadingStatusChange(next2);
      return next2;
    }
  });
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("delayMs" in $$new_props) $$invalidate(5, delayMs = $$new_props.delayMs);
    if ("loadingStatus" in $$new_props) $$invalidate(4, loadingStatus = $$new_props.loadingStatus);
    if ("onLoadingStatusChange" in $$new_props) $$invalidate(6, onLoadingStatusChange = $$new_props.onLoadingStatusChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    setCtx: setCtx3,
    delayMs,
    loadingStatus,
    onLoadingStatusChange,
    asChild,
    el,
    localLoadingStatus,
    updateOption,
    getAttrs: getAttrs2,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("delayMs" in $$props) $$invalidate(5, delayMs = $$new_props.delayMs);
    if ("loadingStatus" in $$props) $$invalidate(4, loadingStatus = $$new_props.loadingStatus);
    if ("onLoadingStatusChange" in $$props) $$invalidate(6, onLoadingStatusChange = $$new_props.onLoadingStatusChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*loadingStatus*/
    16) {
      $: loadingStatus !== void 0 && localLoadingStatus.set(loadingStatus);
    }
    if ($$self.$$.dirty & /*delayMs*/
    32) {
      $: updateOption("delayMs", delayMs);
    }
  };
  return [
    el,
    asChild,
    attrs,
    $$restProps,
    loadingStatus,
    delayMs,
    onLoadingStatusChange,
    $$scope,
    slots,
    div_binding
  ];
}
var Avatar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance16, create_fragment16, safe_not_equal, {
      delayMs: 5,
      loadingStatus: 4,
      onLoadingStatusChange: 6,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Avatar",
      options,
      id: create_fragment16.name
    });
  }
  get delayMs() {
    throw new Error("<Avatar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set delayMs(value) {
    throw new Error("<Avatar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loadingStatus() {
    throw new Error("<Avatar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loadingStatus(value) {
    throw new Error("<Avatar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onLoadingStatusChange() {
    throw new Error("<Avatar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onLoadingStatusChange(value) {
    throw new Error("<Avatar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Avatar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Avatar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Avatar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Avatar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var avatar_default = Avatar;

// node_modules/bits-ui/dist/bits/avatar/components/avatar-image.svelte
var file16 = "node_modules/bits-ui/dist/bits/avatar/components/avatar-image.svelte";
var get_default_slot_changes16 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context16 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
function create_else_block12(ctx) {
  let img;
  let builder_action_action;
  let mounted;
  let dispose;
  let img_levels = [
    /*builder*/
    ctx[3],
    { alt: (
      /*alt*/
      ctx[1]
    ) },
    /*$$restProps*/
    ctx[5]
  ];
  let img_data = {};
  for (let i = 0; i < img_levels.length; i += 1) {
    img_data = assign(img_data, img_levels[i]);
  }
  const block = {
    c: function create() {
      img = element("img");
      this.h();
    },
    l: function claim(nodes) {
      img = claim_element(nodes, "IMG", { alt: true });
      this.h();
    },
    h: function hydrate() {
      set_attributes(img, img_data);
      add_location(img, file16, 20, 1, 394);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, img, anchor);
      ctx[10](img);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[3].action(img));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(img, img_data = get_spread_update(img_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*alt*/
        2 && { alt: (
          /*alt*/
          ctx2[1]
        ) },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(img);
      }
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block12.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block15(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context16
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes16
            ),
            get_default_slot_context16
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block15.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment17(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block15, create_else_block12];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment17.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance17($$self, $$props, $$invalidate) {
  let image;
  let builder;
  const omit_props_names = ["src", "alt", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $image, $$unsubscribe_image = noop, $$subscribe_image = () => ($$unsubscribe_image(), $$unsubscribe_image = subscribe(image, ($$value) => $$invalidate(7, $image = $$value)), image);
  $$self.$$.on_destroy.push(() => $$unsubscribe_image());
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Avatar_image", slots, ["default"]);
  let { src = void 0 } = $$props;
  let { alt = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const attrs = { "data-bits-avatar-image": "" };
  function img_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("src" in $$new_props) $$invalidate(6, src = $$new_props.src);
    if ("alt" in $$new_props) $$invalidate(1, alt = $$new_props.alt);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getImage,
    src,
    alt,
    asChild,
    el,
    attrs,
    builder,
    image,
    $image
  });
  $$self.$inject_state = ($$new_props) => {
    if ("src" in $$props) $$invalidate(6, src = $$new_props.src);
    if ("alt" in $$props) $$invalidate(1, alt = $$new_props.alt);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
    if ("image" in $$props) $$subscribe_image($$invalidate(4, image = $$new_props.image));
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*src*/
    64) {
      $: $$subscribe_image($$invalidate(4, image = getImage(src).elements.image));
    }
    if ($$self.$$.dirty & /*$image*/
    128) {
      $: $$invalidate(3, builder = $image);
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    alt,
    asChild,
    builder,
    image,
    $$restProps,
    src,
    $image,
    $$scope,
    slots,
    img_binding
  ];
}
var Avatar_image = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance17, create_fragment17, safe_not_equal, { src: 6, alt: 1, asChild: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Avatar_image",
      options,
      id: create_fragment17.name
    });
  }
  get src() {
    throw new Error("<Avatar_image>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set src(value) {
    throw new Error("<Avatar_image>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alt() {
    throw new Error("<Avatar_image>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alt(value) {
    throw new Error("<Avatar_image>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Avatar_image>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Avatar_image>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Avatar_image>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Avatar_image>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var avatar_image_default = Avatar_image;

// node_modules/bits-ui/dist/bits/avatar/components/avatar-fallback.svelte
var file17 = "node_modules/bits-ui/dist/bits/avatar/components/avatar-fallback.svelte";
var get_default_slot_changes_114 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_114 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes17 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context17 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block13(ctx) {
  let span;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_114
  );
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      var span_nodes = children(span);
      if (default_slot) default_slot.l(span_nodes);
      span_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file17, 18, 1, 347);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      if (default_slot) {
        default_slot.m(span, null);
      }
      ctx[8](span);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_114
            ),
            get_default_slot_context_114
          );
        }
      }
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block13.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block16(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context17
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes17
            ),
            get_default_slot_context17
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block16.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment18(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block16, create_else_block13];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment18.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance18($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $fallback;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Avatar_fallback", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { fallback }, getAttrs: getAttrs2 } = getCtx3();
  validate_store(fallback, "fallback");
  component_subscribe($$self, fallback, (value) => $$invalidate(5, $fallback = value));
  const attrs = getAttrs2("fallback");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx3,
    asChild,
    el,
    fallback,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $fallback
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$fallback*/
    32) {
      $: $$invalidate(2, builder = $fallback);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    fallback,
    $$restProps,
    $fallback,
    $$scope,
    slots,
    span_binding
  ];
}
var Avatar_fallback = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance18, create_fragment18, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Avatar_fallback",
      options,
      id: create_fragment18.name
    });
  }
  get asChild() {
    throw new Error("<Avatar_fallback>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Avatar_fallback>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Avatar_fallback>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Avatar_fallback>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var avatar_fallback_default = Avatar_fallback;

// node_modules/bits-ui/dist/bits/button/index.js
var button_exports = {};
__export(button_exports, {
  Root: () => button_default
});

// node_modules/bits-ui/dist/helpers/builders.js
function builderActions(node, params) {
  const unsubs = [];
  params.builders.forEach((builder) => {
    const act = builder.action(node);
    if (act) {
      unsubs.push(act);
    }
  });
  return {
    destroy: () => {
      unsubs.forEach((unsub) => {
        if (unsub.destroy) {
          unsub.destroy();
        }
      });
    }
  };
}
function getAttrs(builders) {
  const attrs = {};
  builders.forEach((builder) => {
    Object.keys(builder).forEach((key) => {
      if (key !== "action") {
        attrs[key] = builder[key];
      }
    });
  });
  return attrs;
}

// node_modules/bits-ui/dist/bits/button/components/button.svelte
var file18 = "node_modules/bits-ui/dist/bits/button/components/button.svelte";
function create_else_block14(ctx) {
  let previous_tag = (
    /*href*/
    ctx[1] ? "a" : "button"
  );
  let svelte_element_anchor;
  let current;
  validate_dynamic_element(
    /*href*/
    ctx[1] ? "a" : "button"
  );
  validate_void_dynamic_element(
    /*href*/
    ctx[1] ? "a" : "button"
  );
  let svelte_element = (
    /*href*/
    (ctx[1] ? "a" : "button") && create_dynamic_element_1(ctx)
  );
  const block = {
    c: function create() {
      if (svelte_element) svelte_element.c();
      svelte_element_anchor = empty();
    },
    l: function claim(nodes) {
      if (svelte_element) svelte_element.l(nodes);
      svelte_element_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (svelte_element) svelte_element.m(target, anchor);
      insert_hydration_dev(target, svelte_element_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*href*/
        ctx2[1] ? "a" : "button"
      ) {
        if (!previous_tag) {
          svelte_element = create_dynamic_element_1(ctx2);
          previous_tag = /*href*/
          ctx2[1] ? "a" : "button";
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else if (safe_not_equal(
          previous_tag,
          /*href*/
          ctx2[1] ? "a" : "button"
        )) {
          svelte_element.d(1);
          validate_dynamic_element(
            /*href*/
            ctx2[1] ? "a" : "button"
          );
          validate_void_dynamic_element(
            /*href*/
            ctx2[1] ? "a" : "button"
          );
          svelte_element = create_dynamic_element_1(ctx2);
          previous_tag = /*href*/
          ctx2[1] ? "a" : "button";
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else {
          svelte_element.p(ctx2, dirty);
        }
      } else if (previous_tag) {
        svelte_element.d(1);
        svelte_element = null;
        previous_tag = /*href*/
        ctx2[1] ? "a" : "button";
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(svelte_element, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(svelte_element, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element_anchor);
      }
      if (svelte_element) svelte_element.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block14.name,
    type: "else",
    source: "(32:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block17(ctx) {
  let previous_tag = (
    /*href*/
    ctx[1] ? "a" : "button"
  );
  let svelte_element_anchor;
  let current;
  validate_dynamic_element(
    /*href*/
    ctx[1] ? "a" : "button"
  );
  validate_void_dynamic_element(
    /*href*/
    ctx[1] ? "a" : "button"
  );
  let svelte_element = (
    /*href*/
    (ctx[1] ? "a" : "button") && create_dynamic_element2(ctx)
  );
  const block = {
    c: function create() {
      if (svelte_element) svelte_element.c();
      svelte_element_anchor = empty();
    },
    l: function claim(nodes) {
      if (svelte_element) svelte_element.l(nodes);
      svelte_element_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (svelte_element) svelte_element.m(target, anchor);
      insert_hydration_dev(target, svelte_element_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*href*/
        ctx2[1] ? "a" : "button"
      ) {
        if (!previous_tag) {
          svelte_element = create_dynamic_element2(ctx2);
          previous_tag = /*href*/
          ctx2[1] ? "a" : "button";
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else if (safe_not_equal(
          previous_tag,
          /*href*/
          ctx2[1] ? "a" : "button"
        )) {
          svelte_element.d(1);
          validate_dynamic_element(
            /*href*/
            ctx2[1] ? "a" : "button"
          );
          validate_void_dynamic_element(
            /*href*/
            ctx2[1] ? "a" : "button"
          );
          svelte_element = create_dynamic_element2(ctx2);
          previous_tag = /*href*/
          ctx2[1] ? "a" : "button";
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else {
          svelte_element.p(ctx2, dirty);
        }
      } else if (previous_tag) {
        svelte_element.d(1);
        svelte_element = null;
        previous_tag = /*href*/
        ctx2[1] ? "a" : "button";
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(svelte_element, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(svelte_element, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element_anchor);
      }
      if (svelte_element) svelte_element.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block17.name,
    type: "if",
    source: "(11:0) {#if builders && builders.length}",
    ctx
  });
  return block;
}
function create_dynamic_element_1(ctx) {
  let svelte_element;
  let svelte_element_type_value;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    null
  );
  let svelte_element_levels = [
    {
      type: svelte_element_type_value = /*href*/
      ctx[1] ? void 0 : (
        /*type*/
        ctx[2]
      )
    },
    { href: (
      /*href*/
      ctx[1]
    ) },
    { tabindex: "0" },
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[4]
  ];
  let svelte_element_data = {};
  for (let i = 0; i < svelte_element_levels.length; i += 1) {
    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
  }
  const block = {
    c: function create() {
      svelte_element = element(
        /*href*/
        ctx[1] ? "a" : "button"
      );
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      svelte_element = claim_element(
        nodes,
        /*href*/
        ((ctx[1] ? "a" : "button") || "null").toUpperCase(),
        { type: true, href: true, tabindex: true }
      );
      var svelte_element_nodes = children(svelte_element);
      if (default_slot) default_slot.l(svelte_element_nodes);
      svelte_element_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_dynamic_element_data(
        /*href*/
        ctx[1] ? "a" : "button"
      )(svelte_element, svelte_element_data);
      add_location(svelte_element, file18, 33, 1, 726);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, svelte_element, anchor);
      if (default_slot) {
        default_slot.m(svelte_element, null);
      }
      current = true;
      if (!mounted) {
        dispose = [
          listen_dev(
            svelte_element,
            "click",
            /*click_handler_1*/
            ctx[14],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "change",
            /*change_handler_1*/
            ctx[15],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "keydown",
            /*keydown_handler_1*/
            ctx[16],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "keyup",
            /*keyup_handler_1*/
            ctx[17],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "mouseenter",
            /*mouseenter_handler_1*/
            ctx[18],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "mouseleave",
            /*mouseleave_handler_1*/
            ctx[19],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        64)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_dynamic_element_data(
        /*href*/
        ctx2[1] ? "a" : "button"
      )(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
        (!current || dirty & /*href, type*/
        6 && svelte_element_type_value !== (svelte_element_type_value = /*href*/
        ctx2[1] ? void 0 : (
          /*type*/
          ctx2[2]
        ))) && { type: svelte_element_type_value },
        (!current || dirty & /*href*/
        2) && { href: (
          /*href*/
          ctx2[1]
        ) },
        { tabindex: "0" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        /*attrs*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element);
      }
      if (default_slot) default_slot.d(detaching);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_dynamic_element_1.name,
    type: "child_dynamic_element",
    source: '(34:1) <svelte:element   this={href ? \\"a\\" : \\"button\\"}   type={href ? undefined : type}   {href}   on:click   on:change   on:keydown   on:keyup   on:mouseenter   on:mouseleave   tabindex=\\"0\\"   {...$$restProps}   {...attrs}  >',
    ctx
  });
  return block;
}
function create_dynamic_element2(ctx) {
  let svelte_element;
  let svelte_element_type_value;
  let builderActions_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    null
  );
  let svelte_element_levels = [
    {
      type: svelte_element_type_value = /*href*/
      ctx[1] ? void 0 : (
        /*type*/
        ctx[2]
      )
    },
    { href: (
      /*href*/
      ctx[1]
    ) },
    { tabindex: "0" },
    getAttrs(
      /*builders*/
      ctx[3]
    ),
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[4]
  ];
  let svelte_element_data = {};
  for (let i = 0; i < svelte_element_levels.length; i += 1) {
    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
  }
  const block = {
    c: function create() {
      svelte_element = element(
        /*href*/
        ctx[1] ? "a" : "button"
      );
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      svelte_element = claim_element(
        nodes,
        /*href*/
        ((ctx[1] ? "a" : "button") || "null").toUpperCase(),
        { type: true, href: true, tabindex: true }
      );
      var svelte_element_nodes = children(svelte_element);
      if (default_slot) default_slot.l(svelte_element_nodes);
      svelte_element_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_dynamic_element_data(
        /*href*/
        ctx[1] ? "a" : "button"
      )(svelte_element, svelte_element_data);
      add_location(svelte_element, file18, 12, 1, 330);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, svelte_element, anchor);
      if (default_slot) {
        default_slot.m(svelte_element, null);
      }
      ctx[20](svelte_element);
      current = true;
      if (!mounted) {
        dispose = [
          listen_dev(
            svelte_element,
            "click",
            /*click_handler*/
            ctx[8],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "change",
            /*change_handler*/
            ctx[9],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "keydown",
            /*keydown_handler*/
            ctx[10],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "keyup",
            /*keyup_handler*/
            ctx[11],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "mouseenter",
            /*mouseenter_handler*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "mouseleave",
            /*mouseleave_handler*/
            ctx[13],
            false,
            false,
            false,
            false
          ),
          action_destroyer(builderActions_action = builderActions.call(null, svelte_element, { builders: (
            /*builders*/
            ctx[3]
          ) }))
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        64)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_dynamic_element_data(
        /*href*/
        ctx2[1] ? "a" : "button"
      )(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
        (!current || dirty & /*href, type*/
        6 && svelte_element_type_value !== (svelte_element_type_value = /*href*/
        ctx2[1] ? void 0 : (
          /*type*/
          ctx2[2]
        ))) && { type: svelte_element_type_value },
        (!current || dirty & /*href*/
        2) && { href: (
          /*href*/
          ctx2[1]
        ) },
        { tabindex: "0" },
        dirty & /*builders*/
        8 && getAttrs(
          /*builders*/
          ctx2[3]
        ),
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        /*attrs*/
        ctx2[4]
      ]));
      if (builderActions_action && is_function(builderActions_action.update) && dirty & /*builders*/
      8) builderActions_action.update.call(null, { builders: (
        /*builders*/
        ctx2[3]
      ) });
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[20](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_dynamic_element2.name,
    type: "child_dynamic_element",
    source: '(13:1) <svelte:element   this={href ? \\"a\\" : \\"button\\"}   bind:this={el}   type={href ? undefined : type}   {href}   on:click   on:change   on:keydown   on:keyup   on:mouseenter   on:mouseleave   tabindex=\\"0\\"   use:builderActions={{ builders }}   {...getAttrs(builders)}   {...$$restProps}   {...attrs}  >',
    ctx
  });
  return block;
}
function create_fragment19(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block17, create_else_block14];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*builders*/
      ctx2[3] && /*builders*/
      ctx2[3].length
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment19.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance19($$self, $$props, $$invalidate) {
  const omit_props_names = ["href", "type", "builders", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Button", slots, ["default"]);
  let { href = void 0 } = $$props;
  let { type = void 0 } = $$props;
  let { builders = [] } = $$props;
  let { el = void 0 } = $$props;
  const attrs = { "data-button-root": "" };
  function click_handler(event) {
    bubble.call(this, $$self, event);
  }
  function change_handler(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler(event) {
    bubble.call(this, $$self, event);
  }
  function keyup_handler(event) {
    bubble.call(this, $$self, event);
  }
  function mouseenter_handler(event) {
    bubble.call(this, $$self, event);
  }
  function mouseleave_handler(event) {
    bubble.call(this, $$self, event);
  }
  function click_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function change_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function keyup_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function mouseenter_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function mouseleave_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function svelte_element_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("href" in $$new_props) $$invalidate(1, href = $$new_props.href);
    if ("type" in $$new_props) $$invalidate(2, type = $$new_props.type);
    if ("builders" in $$new_props) $$invalidate(3, builders = $$new_props.builders);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    builderActions,
    getAttrs,
    href,
    type,
    builders,
    el,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("href" in $$props) $$invalidate(1, href = $$new_props.href);
    if ("type" in $$props) $$invalidate(2, type = $$new_props.type);
    if ("builders" in $$props) $$invalidate(3, builders = $$new_props.builders);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [
    el,
    href,
    type,
    builders,
    attrs,
    $$restProps,
    $$scope,
    slots,
    click_handler,
    change_handler,
    keydown_handler,
    keyup_handler,
    mouseenter_handler,
    mouseleave_handler,
    click_handler_1,
    change_handler_1,
    keydown_handler_1,
    keyup_handler_1,
    mouseenter_handler_1,
    mouseleave_handler_1,
    svelte_element_binding
  ];
}
var Button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance19, create_fragment19, safe_not_equal, { href: 1, type: 2, builders: 3, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Button",
      options,
      id: create_fragment19.name
    });
  }
  get href() {
    throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set href(value) {
    throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get type() {
    throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set type(value) {
    throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get builders() {
    throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set builders(value) {
    throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var button_default = Button;

// node_modules/bits-ui/dist/bits/calendar/index.js
var calendar_exports = {};
__export(calendar_exports, {
  Cell: () => calendar_cell_default,
  Day: () => calendar_day_default,
  Grid: () => calendar_grid_default,
  GridBody: () => calendar_grid_body_default,
  GridHead: () => calendar_grid_head_default,
  GridRow: () => calendar_grid_row_default,
  HeadCell: () => calendar_head_cell_default,
  Header: () => calendar_header_default,
  Heading: () => calendar_heading_default,
  NextButton: () => calendar_next_button_default,
  PrevButton: () => calendar_prev_button_default,
  Root: () => calendar_default
});

// node_modules/bits-ui/dist/bits/calendar/ctx.js
function getCalendarData() {
  const NAME = "calendar";
  const PARTS = [
    "root",
    "prev-button",
    "next-button",
    "heading",
    "grid",
    "day",
    "header",
    "grid-head",
    "head-cell",
    "grid-body",
    "cell",
    "grid-row"
  ];
  return { NAME, PARTS };
}
function setCtx4(props) {
  const { NAME, PARTS } = getCalendarData();
  const getCalendarAttrs = createBitAttrs(NAME, PARTS);
  const calendar = { ...createCalendar(removeUndefined2(props)), getCalendarAttrs };
  setContext(NAME, calendar);
  return {
    ...calendar,
    updateOption: getOptionUpdater(calendar.options)
  };
}
function getCtx4() {
  const { NAME } = getCalendarData();
  const ctx = getContext(NAME);
  return ctx;
}

// node_modules/bits-ui/dist/bits/calendar/components/calendar.svelte
var file19 = "node_modules/bits-ui/dist/bits/calendar/components/calendar.svelte";
var get_default_slot_changes_115 = (dirty) => ({
  months: dirty[0] & /*months*/
  8,
  weekdays: dirty[0] & /*$weekdays*/
  16,
  builder: dirty[0] & /*builder*/
  4
});
var get_default_slot_context_115 = (ctx) => ({
  months: (
    /*months*/
    ctx[3]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[4]
  ),
  builder: (
    /*builder*/
    ctx[2]
  )
});
var get_default_slot_changes18 = (dirty) => ({
  months: dirty[0] & /*months*/
  8,
  weekdays: dirty[0] & /*$weekdays*/
  16,
  builder: dirty[0] & /*builder*/
  4
});
var get_default_slot_context18 = (ctx) => ({
  months: (
    /*months*/
    ctx[3]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[4]
  ),
  builder: (
    /*builder*/
    ctx[2]
  )
});
function create_else_block15(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[34].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[33],
    get_default_slot_context_115
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[9]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file19, 134, 1, 3349);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[35](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[8],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*months, $weekdays, builder*/
        28 | dirty[1] & /*$$scope*/
        4)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[33],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[33]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[33],
              dirty,
              get_default_slot_changes_115
            ),
            get_default_slot_context_115
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty[0] & /*$$restProps*/
        512 && /*$$restProps*/
        ctx2[9]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[35](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block15.name,
    type: "else",
    source: "(134:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block18(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[34].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[33],
    get_default_slot_context18
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*months, $weekdays, builder*/
        28 | dirty[1] & /*$$scope*/
        4)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[33],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[33]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[33],
              dirty,
              get_default_slot_changes18
            ),
            get_default_slot_context18
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block18.name,
    type: "if",
    source: "(132:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment20(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block18, create_else_block15];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, [-1, -1]);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment20.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance20($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "placeholder",
    "onPlaceholderChange",
    "value",
    "onValueChange",
    "preventDeselect",
    "minValue",
    "maxValue",
    "pagedNavigation",
    "weekStartsOn",
    "locale",
    "isDateUnavailable",
    "isDateDisabled",
    "disabled",
    "readonly",
    "fixedWeeks",
    "calendarLabel",
    "weekdayFormat",
    "multiple",
    "asChild",
    "id",
    "numberOfMonths",
    "initialFocus",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $localMonths;
  let $calendar;
  let $weekdays;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar", slots, ["default"]);
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { preventDeselect = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { pagedNavigation = void 0 } = $$props;
  let { weekStartsOn = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { isDateDisabled = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  let { fixedWeeks = void 0 } = $$props;
  let { calendarLabel = void 0 } = $$props;
  let { weekdayFormat = void 0 } = $$props;
  let { multiple = false } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { numberOfMonths = void 0 } = $$props;
  let { initialFocus = false } = $$props;
  let { el = void 0 } = $$props;
  onMount(() => {
    if (!initialFocus || !el) return;
    handleCalendarInitialFocus(el);
  });
  const { elements: { calendar }, states: { value: localValue, placeholder: localPlaceholder, months: localMonths, weekdays }, updateOption, ids, getCalendarAttrs } = setCtx4({
    defaultPlaceholder: placeholder,
    defaultValue: value,
    preventDeselect,
    minValue,
    maxValue,
    pagedNavigation,
    weekStartsOn,
    locale,
    isDateUnavailable,
    isDateDisabled,
    disabled,
    readonly: readonly2,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    multiple,
    numberOfMonths,
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(10, placeholder = next2);
      }
      return next2;
    },
    onValueChange: ({ next: next2 }) => {
      if (Array.isArray(next2)) {
        if (!Array.isArray(value) || !arraysAreEqual(value, next2)) {
          onValueChange == null ? void 0 : onValueChange(next2);
          $$invalidate(11, value = next2);
          return next2;
        }
        return next2;
      }
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(11, value = next2);
      }
      return next2;
    }
  });
  validate_store(calendar, "calendar");
  component_subscribe($$self, calendar, (value2) => $$invalidate(32, $calendar = value2));
  validate_store(localMonths, "localMonths");
  component_subscribe($$self, localMonths, (value2) => $$invalidate(31, $localMonths = value2));
  validate_store(weekdays, "weekdays");
  component_subscribe($$self, weekdays, (value2) => $$invalidate(4, $weekdays = value2));
  const attrs = getCalendarAttrs("root");
  const dispatch = createDispatcher();
  let months = $localMonths;
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(9, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("placeholder" in $$new_props) $$invalidate(10, placeholder = $$new_props.placeholder);
    if ("onPlaceholderChange" in $$new_props) $$invalidate(12, onPlaceholderChange = $$new_props.onPlaceholderChange);
    if ("value" in $$new_props) $$invalidate(11, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(13, onValueChange = $$new_props.onValueChange);
    if ("preventDeselect" in $$new_props) $$invalidate(14, preventDeselect = $$new_props.preventDeselect);
    if ("minValue" in $$new_props) $$invalidate(15, minValue = $$new_props.minValue);
    if ("maxValue" in $$new_props) $$invalidate(16, maxValue = $$new_props.maxValue);
    if ("pagedNavigation" in $$new_props) $$invalidate(17, pagedNavigation = $$new_props.pagedNavigation);
    if ("weekStartsOn" in $$new_props) $$invalidate(18, weekStartsOn = $$new_props.weekStartsOn);
    if ("locale" in $$new_props) $$invalidate(19, locale = $$new_props.locale);
    if ("isDateUnavailable" in $$new_props) $$invalidate(20, isDateUnavailable = $$new_props.isDateUnavailable);
    if ("isDateDisabled" in $$new_props) $$invalidate(21, isDateDisabled = $$new_props.isDateDisabled);
    if ("disabled" in $$new_props) $$invalidate(22, disabled = $$new_props.disabled);
    if ("readonly" in $$new_props) $$invalidate(23, readonly2 = $$new_props.readonly);
    if ("fixedWeeks" in $$new_props) $$invalidate(24, fixedWeeks = $$new_props.fixedWeeks);
    if ("calendarLabel" in $$new_props) $$invalidate(25, calendarLabel = $$new_props.calendarLabel);
    if ("weekdayFormat" in $$new_props) $$invalidate(26, weekdayFormat = $$new_props.weekdayFormat);
    if ("multiple" in $$new_props) $$invalidate(27, multiple = $$new_props.multiple);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(28, id = $$new_props.id);
    if ("numberOfMonths" in $$new_props) $$invalidate(29, numberOfMonths = $$new_props.numberOfMonths);
    if ("initialFocus" in $$new_props) $$invalidate(30, initialFocus = $$new_props.initialFocus);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(33, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    arraysAreEqual,
    handleCalendarInitialFocus,
    createDispatcher,
    melt,
    onMount,
    setCtx: setCtx4,
    placeholder,
    onPlaceholderChange,
    value,
    onValueChange,
    preventDeselect,
    minValue,
    maxValue,
    pagedNavigation,
    weekStartsOn,
    locale,
    isDateUnavailable,
    isDateDisabled,
    disabled,
    readonly: readonly2,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    multiple,
    asChild,
    id,
    numberOfMonths,
    initialFocus,
    el,
    calendar,
    localValue,
    localPlaceholder,
    localMonths,
    weekdays,
    updateOption,
    ids,
    getCalendarAttrs,
    attrs,
    dispatch,
    months,
    builder,
    $localMonths,
    $calendar,
    $weekdays
  });
  $$self.$inject_state = ($$new_props) => {
    if ("placeholder" in $$props) $$invalidate(10, placeholder = $$new_props.placeholder);
    if ("onPlaceholderChange" in $$props) $$invalidate(12, onPlaceholderChange = $$new_props.onPlaceholderChange);
    if ("value" in $$props) $$invalidate(11, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(13, onValueChange = $$new_props.onValueChange);
    if ("preventDeselect" in $$props) $$invalidate(14, preventDeselect = $$new_props.preventDeselect);
    if ("minValue" in $$props) $$invalidate(15, minValue = $$new_props.minValue);
    if ("maxValue" in $$props) $$invalidate(16, maxValue = $$new_props.maxValue);
    if ("pagedNavigation" in $$props) $$invalidate(17, pagedNavigation = $$new_props.pagedNavigation);
    if ("weekStartsOn" in $$props) $$invalidate(18, weekStartsOn = $$new_props.weekStartsOn);
    if ("locale" in $$props) $$invalidate(19, locale = $$new_props.locale);
    if ("isDateUnavailable" in $$props) $$invalidate(20, isDateUnavailable = $$new_props.isDateUnavailable);
    if ("isDateDisabled" in $$props) $$invalidate(21, isDateDisabled = $$new_props.isDateDisabled);
    if ("disabled" in $$props) $$invalidate(22, disabled = $$new_props.disabled);
    if ("readonly" in $$props) $$invalidate(23, readonly2 = $$new_props.readonly);
    if ("fixedWeeks" in $$props) $$invalidate(24, fixedWeeks = $$new_props.fixedWeeks);
    if ("calendarLabel" in $$props) $$invalidate(25, calendarLabel = $$new_props.calendarLabel);
    if ("weekdayFormat" in $$props) $$invalidate(26, weekdayFormat = $$new_props.weekdayFormat);
    if ("multiple" in $$props) $$invalidate(27, multiple = $$new_props.multiple);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(28, id = $$new_props.id);
    if ("numberOfMonths" in $$props) $$invalidate(29, numberOfMonths = $$new_props.numberOfMonths);
    if ("initialFocus" in $$props) $$invalidate(30, initialFocus = $$new_props.initialFocus);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("months" in $$props) $$invalidate(3, months = $$new_props.months);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    268435456) {
      $: if (id) {
        ids.calendar.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*value*/
    2048) {
      $: value !== void 0 && localValue.set(
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        Array.isArray(value) ? [...value] : value
      );
    }
    if ($$self.$$.dirty[0] & /*placeholder*/
    1024) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty[0] & /*preventDeselect*/
    16384) {
      $: updateOption("preventDeselect", preventDeselect);
    }
    if ($$self.$$.dirty[0] & /*minValue*/
    32768) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty[0] & /*maxValue*/
    65536) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty[0] & /*pagedNavigation*/
    131072) {
      $: updateOption("pagedNavigation", pagedNavigation);
    }
    if ($$self.$$.dirty[0] & /*weekStartsOn*/
    262144) {
      $: updateOption("weekStartsOn", weekStartsOn);
    }
    if ($$self.$$.dirty[0] & /*locale*/
    524288) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty[0] & /*isDateUnavailable*/
    1048576) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty[0] & /*isDateDisabled*/
    2097152) {
      $: updateOption("isDateDisabled", isDateDisabled);
    }
    if ($$self.$$.dirty[0] & /*disabled*/
    4194304) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty[0] & /*readonly*/
    8388608) {
      $: updateOption("readonly", readonly2);
    }
    if ($$self.$$.dirty[0] & /*fixedWeeks*/
    16777216) {
      $: updateOption("fixedWeeks", fixedWeeks);
    }
    if ($$self.$$.dirty[0] & /*calendarLabel*/
    33554432) {
      $: updateOption("calendarLabel", calendarLabel);
    }
    if ($$self.$$.dirty[0] & /*weekdayFormat*/
    67108864) {
      $: updateOption("weekdayFormat", weekdayFormat);
    }
    if ($$self.$$.dirty[0] & /*numberOfMonths*/
    536870912) {
      $: updateOption("numberOfMonths", numberOfMonths);
    }
    if ($$self.$$.dirty[1] & /*$calendar*/
    2) {
      $: $$invalidate(2, builder = $calendar);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[1] & /*$localMonths*/
    1) {
      $: $$invalidate(3, months = $localMonths);
    }
  };
  return [
    el,
    asChild,
    builder,
    months,
    $weekdays,
    calendar,
    localMonths,
    weekdays,
    dispatch,
    $$restProps,
    placeholder,
    value,
    onPlaceholderChange,
    onValueChange,
    preventDeselect,
    minValue,
    maxValue,
    pagedNavigation,
    weekStartsOn,
    locale,
    isDateUnavailable,
    isDateDisabled,
    disabled,
    readonly2,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    multiple,
    id,
    numberOfMonths,
    initialFocus,
    $localMonths,
    $calendar,
    $$scope,
    slots,
    div_binding
  ];
}
var Calendar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance20,
      create_fragment20,
      safe_not_equal,
      {
        placeholder: 10,
        onPlaceholderChange: 12,
        value: 11,
        onValueChange: 13,
        preventDeselect: 14,
        minValue: 15,
        maxValue: 16,
        pagedNavigation: 17,
        weekStartsOn: 18,
        locale: 19,
        isDateUnavailable: 20,
        isDateDisabled: 21,
        disabled: 22,
        readonly: 23,
        fixedWeeks: 24,
        calendarLabel: 25,
        weekdayFormat: 26,
        multiple: 27,
        asChild: 1,
        id: 28,
        numberOfMonths: 29,
        initialFocus: 30,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar",
      options,
      id: create_fragment20.name
    });
  }
  get placeholder() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventDeselect() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventDeselect(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get pagedNavigation() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set pagedNavigation(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekStartsOn() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekStartsOn(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateDisabled() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateDisabled(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fixedWeeks() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fixedWeeks(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get calendarLabel() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set calendarLabel(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekdayFormat() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekdayFormat(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get multiple() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set multiple(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get numberOfMonths() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set numberOfMonths(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get initialFocus() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set initialFocus(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_default = Calendar;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-day.svelte
var file20 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-day.svelte";
var get_default_slot_changes_116 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  64,
  unavailable: dirty & /*unavailable*/
  32,
  selected: dirty & /*selected*/
  16
});
var get_default_slot_context_116 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[6]
  ),
  unavailable: (
    /*unavailable*/
    ctx[5]
  ),
  selected: (
    /*selected*/
    ctx[4]
  )
});
var get_default_slot_changes19 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  64,
  unavailable: dirty & /*unavailable*/
  32,
  selected: dirty & /*selected*/
  16
});
var get_default_slot_context19 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[6]
  ),
  unavailable: (
    /*unavailable*/
    ctx[5]
  ),
  selected: (
    /*selected*/
    ctx[4]
  )
});
function create_else_block16(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[19].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[18],
    get_default_slot_context_116
  );
  const default_slot_or_fallback = default_slot || fallback_block(ctx);
  let div_levels = [
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file20, 29, 1, 724);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[20](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[3].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[11],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable, selected*/
        262264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[18],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[18]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[18],
              dirty,
              get_default_slot_changes_116
            ),
            get_default_slot_context_116
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*date*/
        2)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[20](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block16.name,
    type: "else",
    source: "(29:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block19(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[19].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[18],
    get_default_slot_context19
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable, selected*/
        262264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[18],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[18]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[18],
              dirty,
              get_default_slot_changes19
            ),
            get_default_slot_context19
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block19.name,
    type: "if",
    source: "(27:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block(ctx) {
  let t_value = (
    /*date*/
    ctx[1].day + ""
  );
  let t;
  const block = {
    c: function create() {
      t = text(t_value);
    },
    l: function claim(nodes) {
      t = claim_text(nodes, t_value);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*date*/
      2 && t_value !== (t_value = /*date*/
      ctx2[1].day + "")) set_data_dev(t, t_value);
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block.name,
    type: "fallback",
    source: "(31:54)     ",
    ctx
  });
  return block;
}
function create_fragment21(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block19, create_else_block16];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment21.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance21($$self, $$props, $$invalidate) {
  let builder;
  let disabled;
  let unavailable;
  let selected;
  const omit_props_names = ["date", "month", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateSelected;
  let $isDateUnavailable;
  let $isDateDisabled;
  let $cell;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_day", slots, ["default"]);
  let { date } = $$props;
  let { month } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { cell }, helpers: { isDateDisabled, isDateUnavailable, isDateSelected }, getCalendarAttrs } = getCtx4();
  validate_store(cell, "cell");
  component_subscribe($$self, cell, (value) => $$invalidate(17, $cell = value));
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(16, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(15, $isDateUnavailable = value));
  validate_store(isDateSelected, "isDateSelected");
  component_subscribe($$self, isDateSelected, (value) => $$invalidate(14, $isDateSelected = value));
  const attrs = getCalendarAttrs("day");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Calendar_day> was created without expected prop 'date'");
    }
    if (month === void 0 && !("month" in $$props || $$self.$$.bound[$$self.$$.props["month"]])) {
      console.warn("<Calendar_day> was created without expected prop 'month'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$new_props) $$invalidate(13, month = $$new_props.month);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(18, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx4,
    createDispatcher,
    date,
    month,
    asChild,
    el,
    cell,
    isDateDisabled,
    isDateUnavailable,
    isDateSelected,
    getCalendarAttrs,
    attrs,
    dispatch,
    selected,
    unavailable,
    disabled,
    builder,
    $isDateSelected,
    $isDateUnavailable,
    $isDateDisabled,
    $cell
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$props) $$invalidate(13, month = $$new_props.month);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("selected" in $$props) $$invalidate(4, selected = $$new_props.selected);
    if ("unavailable" in $$props) $$invalidate(5, unavailable = $$new_props.unavailable);
    if ("disabled" in $$props) $$invalidate(6, disabled = $$new_props.disabled);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$cell, date, month*/
    139266) {
      $: $$invalidate(3, builder = $cell(date, month));
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$isDateDisabled, date*/
    65538) {
      $: $$invalidate(6, disabled = $isDateDisabled(date));
    }
    if ($$self.$$.dirty & /*$isDateUnavailable, date*/
    32770) {
      $: $$invalidate(5, unavailable = $isDateUnavailable(date));
    }
    if ($$self.$$.dirty & /*$isDateSelected, date*/
    16386) {
      $: $$invalidate(4, selected = $isDateSelected(date));
    }
  };
  return [
    el,
    date,
    asChild,
    builder,
    selected,
    unavailable,
    disabled,
    cell,
    isDateDisabled,
    isDateUnavailable,
    isDateSelected,
    dispatch,
    $$restProps,
    month,
    $isDateSelected,
    $isDateUnavailable,
    $isDateDisabled,
    $cell,
    $$scope,
    slots,
    div_binding
  ];
}
var Calendar_day = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance21, create_fragment21, safe_not_equal, { date: 1, month: 13, asChild: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_day",
      options,
      id: create_fragment21.name
    });
  }
  get date() {
    throw new Error("<Calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get month() {
    throw new Error("<Calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set month(value) {
    throw new Error("<Calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_day_default = Calendar_day;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-grid.svelte
var file21 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-grid.svelte";
var get_default_slot_changes_117 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_117 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes20 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context20 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block17(ctx) {
  let table;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_117
  );
  let table_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let table_data = {};
  for (let i = 0; i < table_levels.length; i += 1) {
    table_data = assign(table_data, table_levels[i]);
  }
  const block = {
    c: function create() {
      table = element("table");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      table = claim_element(nodes, "TABLE", {});
      var table_nodes = children(table);
      if (default_slot) default_slot.l(table_nodes);
      table_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(table, table_data);
      add_location(table, file21, 18, 1, 351);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, table, anchor);
      if (default_slot) {
        default_slot.m(table, null);
      }
      ctx[8](table);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(table));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_117
            ),
            get_default_slot_context_117
          );
        }
      }
      set_attributes(table, table_data = get_spread_update(table_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(table);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block17.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block20(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context20
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes20
            ),
            get_default_slot_context20
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block20.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment22(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block20, create_else_block17];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment22.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance22($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $grid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_grid", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { grid }, getCalendarAttrs } = getCtx4();
  validate_store(grid, "grid");
  component_subscribe($$self, grid, (value) => $$invalidate(5, $grid = value));
  const attrs = getCalendarAttrs("grid");
  function table_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx4,
    asChild,
    el,
    grid,
    getCalendarAttrs,
    attrs,
    builder,
    $grid
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$grid*/
    32) {
      $: $$invalidate(2, builder = $grid);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, grid, $$restProps, $grid, $$scope, slots, table_binding];
}
var Calendar_grid = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance22, create_fragment22, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_grid",
      options,
      id: create_fragment22.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_grid_default = Calendar_grid;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-grid-body.svelte
var file22 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-grid-body.svelte";
var get_default_slot_changes_118 = (dirty) => ({});
var get_default_slot_context_118 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes21 = (dirty) => ({});
var get_default_slot_context21 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block18(ctx) {
  let tbody;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_118
  );
  let tbody_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tbody_data = {};
  for (let i = 0; i < tbody_levels.length; i += 1) {
    tbody_data = assign(tbody_data, tbody_levels[i]);
  }
  const block = {
    c: function create() {
      tbody = element("tbody");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tbody = claim_element(nodes, "TBODY", {});
      var tbody_nodes = children(tbody);
      if (default_slot) default_slot.l(tbody_nodes);
      tbody_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tbody, tbody_data);
      add_location(tbody, file22, 10, 1, 232);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tbody, anchor);
      if (default_slot) {
        default_slot.m(tbody, null);
      }
      ctx[6](tbody);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_118
            ),
            get_default_slot_context_118
          );
        }
      }
      set_attributes(tbody, tbody_data = get_spread_update(tbody_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tbody);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block18.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block21(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context21
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes21
            ),
            get_default_slot_context21
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block21.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment23(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block21, create_else_block18];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment23.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance23($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_grid_body", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx4();
  const attrs = getCalendarAttrs("grid-body");
  function tbody_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx4,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tbody_binding];
}
var Calendar_grid_body = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance23, create_fragment23, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_grid_body",
      options,
      id: create_fragment23.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_grid_body_default = Calendar_grid_body;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-cell.svelte
var file23 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-cell.svelte";
var get_default_slot_changes_119 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context_119 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes22 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context22 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block19(ctx) {
  let td;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_119
  );
  let td_levels = [
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[2]
  ];
  let td_data = {};
  for (let i = 0; i < td_levels.length; i += 1) {
    td_data = assign(td_data, td_levels[i]);
  }
  const block = {
    c: function create() {
      td = element("td");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      td = claim_element(nodes, "TD", {});
      var td_nodes = children(td);
      if (default_slot) default_slot.l(td_nodes);
      td_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(td, td_data);
      add_location(td, file23, 20, 1, 460);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, td, anchor);
      if (default_slot) {
        default_slot.m(td, null);
      }
      ctx[11](td);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_119
            ),
            get_default_slot_context_119
          );
        }
      }
      set_attributes(td, td_data = get_spread_update(td_levels, [
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        dirty & /*attrs*/
        4 && /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(td);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block19.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block22(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context22
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes22
            ),
            get_default_slot_context22
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block22.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment24(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block22, create_else_block19];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment24.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance24($$self, $$props, $$invalidate) {
  let attrs;
  const omit_props_names = ["date", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateDisabled;
  let $isDateUnavailable;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_cell", slots, ["default"]);
  let { date } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { helpers: { isDateDisabled, isDateUnavailable }, getCalendarAttrs } = getCtx4();
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(7, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(8, $isDateUnavailable = value));
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Calendar_cell> was created without expected prop 'date'");
    }
  });
  function td_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx4,
    date,
    asChild,
    el,
    isDateDisabled,
    isDateUnavailable,
    getCalendarAttrs,
    attrs,
    $isDateDisabled,
    $isDateUnavailable
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(2, attrs = $$new_props.attrs);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$isDateDisabled, date, $isDateUnavailable*/
    448) {
      $: $$invalidate(2, attrs = {
        ...getCalendarAttrs("cell"),
        "aria-disabled": $isDateDisabled(date) || $isDateUnavailable(date),
        "data-disabled": $isDateDisabled(date) ? "" : void 0,
        role: "gridcell"
      });
    }
  };
  return [
    el,
    asChild,
    attrs,
    isDateDisabled,
    isDateUnavailable,
    $$restProps,
    date,
    $isDateDisabled,
    $isDateUnavailable,
    $$scope,
    slots,
    td_binding
  ];
}
var Calendar_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance24, create_fragment24, safe_not_equal, { date: 6, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_cell",
      options,
      id: create_fragment24.name
    });
  }
  get date() {
    throw new Error("<Calendar_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Calendar_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Calendar_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_cell_default = Calendar_cell;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-grid-head.svelte
var file24 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-grid-head.svelte";
var get_default_slot_changes_120 = (dirty) => ({});
var get_default_slot_context_120 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes23 = (dirty) => ({});
var get_default_slot_context23 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block20(ctx) {
  let thead;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_120
  );
  let thead_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let thead_data = {};
  for (let i = 0; i < thead_levels.length; i += 1) {
    thead_data = assign(thead_data, thead_levels[i]);
  }
  const block = {
    c: function create() {
      thead = element("thead");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      thead = claim_element(nodes, "THEAD", {});
      var thead_nodes = children(thead);
      if (default_slot) default_slot.l(thead_nodes);
      thead_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(thead, thead_data);
      add_location(thead, file24, 13, 1, 264);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, thead, anchor);
      if (default_slot) {
        default_slot.m(thead, null);
      }
      ctx[6](thead);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_120
            ),
            get_default_slot_context_120
          );
        }
      }
      set_attributes(thead, thead_data = get_spread_update(thead_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(thead);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block20.name,
    type: "else",
    source: "(13:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block23(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context23
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes23
            ),
            get_default_slot_context23
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block23.name,
    type: "if",
    source: "(11:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment25(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block23, create_else_block20];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment25.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance25($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_grid_head", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx4();
  const attrs = {
    ...getCalendarAttrs("grid-head"),
    "aria-hidden": true
  };
  function thead_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx4,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, thead_binding];
}
var Calendar_grid_head = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance25, create_fragment25, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_grid_head",
      options,
      id: create_fragment25.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_grid_head_default = Calendar_grid_head;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-head-cell.svelte
var file25 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-head-cell.svelte";
var get_default_slot_changes_121 = (dirty) => ({});
var get_default_slot_context_121 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes24 = (dirty) => ({});
var get_default_slot_context24 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block21(ctx) {
  let th;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_121
  );
  let th_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let th_data = {};
  for (let i = 0; i < th_levels.length; i += 1) {
    th_data = assign(th_data, th_levels[i]);
  }
  const block = {
    c: function create() {
      th = element("th");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      th = claim_element(nodes, "TH", {});
      var th_nodes = children(th);
      if (default_slot) default_slot.l(th_nodes);
      th_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(th, th_data);
      add_location(th, file25, 10, 1, 232);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, th, anchor);
      if (default_slot) {
        default_slot.m(th, null);
      }
      ctx[6](th);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_121
            ),
            get_default_slot_context_121
          );
        }
      }
      set_attributes(th, th_data = get_spread_update(th_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(th);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block21.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block24(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context24
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes24
            ),
            get_default_slot_context24
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block24.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment26(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block24, create_else_block21];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment26.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance26($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_head_cell", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx4();
  const attrs = getCalendarAttrs("head-cell");
  function th_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx4,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, th_binding];
}
var Calendar_head_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance26, create_fragment26, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_head_cell",
      options,
      id: create_fragment26.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_head_cell_default = Calendar_head_cell;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-grid-row.svelte
var file26 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-grid-row.svelte";
var get_default_slot_changes_122 = (dirty) => ({});
var get_default_slot_context_122 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes25 = (dirty) => ({});
var get_default_slot_context25 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block22(ctx) {
  let tr;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_122
  );
  let tr_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tr_data = {};
  for (let i = 0; i < tr_levels.length; i += 1) {
    tr_data = assign(tr_data, tr_levels[i]);
  }
  const block = {
    c: function create() {
      tr = element("tr");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tr = claim_element(nodes, "TR", {});
      var tr_nodes = children(tr);
      if (default_slot) default_slot.l(tr_nodes);
      tr_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tr, tr_data);
      add_location(tr, file26, 10, 1, 231);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tr, anchor);
      if (default_slot) {
        default_slot.m(tr, null);
      }
      ctx[6](tr);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_122
            ),
            get_default_slot_context_122
          );
        }
      }
      set_attributes(tr, tr_data = get_spread_update(tr_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tr);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block22.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block25(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context25
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes25
            ),
            get_default_slot_context25
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block25.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment27(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block25, create_else_block22];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment27.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance27($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_grid_row", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx4();
  const attrs = getCalendarAttrs("grid-row");
  function tr_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx4,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tr_binding];
}
var Calendar_grid_row = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance27, create_fragment27, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_grid_row",
      options,
      id: create_fragment27.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_grid_row_default = Calendar_grid_row;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-header.svelte
var file27 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-header.svelte";
var get_default_slot_changes_123 = (dirty) => ({});
var get_default_slot_context_123 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes26 = (dirty) => ({});
var get_default_slot_context26 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block23(ctx) {
  let header;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_123
  );
  let header_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let header_data = {};
  for (let i = 0; i < header_levels.length; i += 1) {
    header_data = assign(header_data, header_levels[i]);
  }
  const block = {
    c: function create() {
      header = element("header");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      header = claim_element(nodes, "HEADER", {});
      var header_nodes = children(header);
      if (default_slot) default_slot.l(header_nodes);
      header_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(header, header_data);
      add_location(header, file27, 10, 1, 229);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, header, anchor);
      if (default_slot) {
        default_slot.m(header, null);
      }
      ctx[6](header);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_123
            ),
            get_default_slot_context_123
          );
        }
      }
      set_attributes(header, header_data = get_spread_update(header_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(header);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block23.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block26(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context26
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes26
            ),
            get_default_slot_context26
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block26.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment28(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block26, create_else_block23];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment28.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance28($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_header", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx4();
  const attrs = getCalendarAttrs("header");
  function header_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx4,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, header_binding];
}
var Calendar_header = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance28, create_fragment28, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_header",
      options,
      id: create_fragment28.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_header_default = Calendar_header;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-heading.svelte
var file28 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-heading.svelte";
var get_default_slot_changes_124 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context_124 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
var get_default_slot_changes27 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context27 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
function create_else_block24(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_124
  );
  const default_slot_or_fallback = default_slot || fallback_block2(ctx);
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file28, 19, 1, 417);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_124
            ),
            get_default_slot_context_124
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*$headingValue*/
        8)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block24.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block27(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context27
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes27
            ),
            get_default_slot_context27
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block27.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block2(ctx) {
  let t;
  const block = {
    c: function create() {
      t = text(
        /*$headingValue*/
        ctx[3]
      );
    },
    l: function claim(nodes) {
      t = claim_text(
        nodes,
        /*$headingValue*/
        ctx[3]
      );
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*$headingValue*/
      8) set_data_dev(
        t,
        /*$headingValue*/
        ctx2[3]
      );
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block2.name,
    type: "fallback",
    source: "(21:47)     ",
    ctx
  });
  return block;
}
function create_fragment29(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block27, create_else_block24];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment29.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance29($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $heading;
  let $headingValue;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_heading", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { heading }, states: { headingValue }, getCalendarAttrs } = getCtx4();
  validate_store(heading, "heading");
  component_subscribe($$self, heading, (value) => $$invalidate(7, $heading = value));
  validate_store(headingValue, "headingValue");
  component_subscribe($$self, headingValue, (value) => $$invalidate(3, $headingValue = value));
  const attrs = getCalendarAttrs("heading");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx4,
    asChild,
    el,
    heading,
    headingValue,
    getCalendarAttrs,
    attrs,
    builder,
    $heading,
    $headingValue
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$heading*/
    128) {
      $: $$invalidate(2, builder = $heading);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $headingValue,
    heading,
    headingValue,
    $$restProps,
    $heading,
    $$scope,
    slots,
    div_binding
  ];
}
var Calendar_heading = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance29, create_fragment29, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_heading",
      options,
      id: create_fragment29.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_heading_default = Calendar_heading;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-next-button.svelte
var file29 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-next-button.svelte";
var get_default_slot_changes_125 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_125 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes28 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context28 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block25(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_125
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file29, 20, 1, 471);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_125
            ),
            get_default_slot_context_125
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block25.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block28(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context28
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes28
            ),
            get_default_slot_context28
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block28.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment30(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block28, create_else_block25];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment30.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance30($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $nextButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_next_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { nextButton }, getCalendarAttrs } = getCtx4();
  validate_store(nextButton, "nextButton");
  component_subscribe($$self, nextButton, (value) => $$invalidate(6, $nextButton = value));
  const attrs = getCalendarAttrs("next-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx4,
    createDispatcher,
    asChild,
    el,
    nextButton,
    getCalendarAttrs,
    attrs,
    dispatch,
    builder,
    $nextButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$nextButton*/
    64) {
      $: $$invalidate(2, builder = $nextButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    nextButton,
    dispatch,
    $$restProps,
    $nextButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Calendar_next_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance30, create_fragment30, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_next_button",
      options,
      id: create_fragment30.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_next_button_default = Calendar_next_button;

// node_modules/bits-ui/dist/bits/calendar/components/calendar-prev-button.svelte
var file30 = "node_modules/bits-ui/dist/bits/calendar/components/calendar-prev-button.svelte";
var get_default_slot_changes_126 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_126 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes29 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context29 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block26(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_126
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file30, 20, 1, 471);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_126
            ),
            get_default_slot_context_126
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block26.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block29(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context29
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes29
            ),
            get_default_slot_context29
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block29.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment31(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block29, create_else_block26];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment31.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance31($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $prevButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Calendar_prev_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { prevButton }, getCalendarAttrs } = getCtx4();
  validate_store(prevButton, "prevButton");
  component_subscribe($$self, prevButton, (value) => $$invalidate(6, $prevButton = value));
  const attrs = getCalendarAttrs("prev-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx4,
    createDispatcher,
    asChild,
    el,
    prevButton,
    getCalendarAttrs,
    attrs,
    dispatch,
    builder,
    $prevButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$prevButton*/
    64) {
      $: $$invalidate(2, builder = $prevButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    prevButton,
    dispatch,
    $$restProps,
    $prevButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Calendar_prev_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance31, create_fragment31, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Calendar_prev_button",
      options,
      id: create_fragment31.name
    });
  }
  get asChild() {
    throw new Error("<Calendar_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Calendar_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Calendar_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Calendar_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var calendar_prev_button_default = Calendar_prev_button;

// node_modules/bits-ui/dist/bits/checkbox/index.js
var checkbox_exports = {};
__export(checkbox_exports, {
  Indicator: () => checkbox_indicator_default,
  Input: () => checkbox_input_default,
  Root: () => checkbox_default
});

// node_modules/bits-ui/dist/bits/checkbox/ctx.js
function getCheckboxData() {
  const NAME = "checkbox";
  const PARTS = ["root", "input", "indicator"];
  return {
    NAME,
    PARTS
  };
}
function setCtx5(props) {
  const { NAME, PARTS } = getCheckboxData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const checkbox = { ...createCheckbox(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, checkbox);
  return {
    ...checkbox,
    updateOption: getOptionUpdater(checkbox.options)
  };
}
function getCtx5() {
  const { NAME } = getCheckboxData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/checkbox/components/checkbox.svelte
var file31 = "node_modules/bits-ui/dist/bits/checkbox/components/checkbox.svelte";
var get_default_slot_changes_127 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_127 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes30 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context30 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block27(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_127
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file31, 52, 1, 1127);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[16](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16388)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes_127
            ),
            get_default_slot_context_127
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[16](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block27.name,
    type: "else",
    source: "(52:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block30(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context30
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16388)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes30
            ),
            get_default_slot_context30
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block30.name,
    type: "if",
    source: "(50:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment32(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block30, create_else_block27];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment32.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance32($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = [
    "checked",
    "disabled",
    "name",
    "required",
    "value",
    "onCheckedChange",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Checkbox", slots, ["default"]);
  let { checked = false } = $$props;
  let { disabled = void 0 } = $$props;
  let { name: name27 = void 0 } = $$props;
  let { required = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onCheckedChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { checked: localChecked }, updateOption, getAttrs: getAttrs2 } = setCtx5({
    defaultChecked: checked,
    disabled,
    name: name27,
    required,
    value,
    onCheckedChange: ({ next: next2 }) => {
      if (checked !== next2) {
        onCheckedChange == null ? void 0 : onCheckedChange(next2);
        $$invalidate(6, checked = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(13, $root = value2));
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("checked" in $$new_props) $$invalidate(6, checked = $$new_props.checked);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("name" in $$new_props) $$invalidate(8, name27 = $$new_props.name);
    if ("required" in $$new_props) $$invalidate(9, required = $$new_props.required);
    if ("value" in $$new_props) $$invalidate(10, value = $$new_props.value);
    if ("onCheckedChange" in $$new_props) $$invalidate(11, onCheckedChange = $$new_props.onCheckedChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(14, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx5,
    createDispatcher,
    checked,
    disabled,
    name: name27,
    required,
    value,
    onCheckedChange,
    asChild,
    el,
    root,
    localChecked,
    updateOption,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("checked" in $$props) $$invalidate(6, checked = $$new_props.checked);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("name" in $$props) $$invalidate(8, name27 = $$new_props.name);
    if ("required" in $$props) $$invalidate(9, required = $$new_props.required);
    if ("value" in $$props) $$invalidate(10, value = $$new_props.value);
    if ("onCheckedChange" in $$props) $$invalidate(11, onCheckedChange = $$new_props.onCheckedChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(12, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: $$invalidate(12, attrs = {
        ...getAttrs2("root"),
        disabled: disabled ? true : void 0
      });
    }
    if ($$self.$$.dirty & /*checked*/
    64) {
      $: checked !== void 0 && localChecked.set(checked);
    }
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*name*/
    256) {
      $: updateOption("name", name27);
    }
    if ($$self.$$.dirty & /*required*/
    512) {
      $: updateOption("required", required);
    }
    if ($$self.$$.dirty & /*value*/
    1024) {
      $: updateOption("value", value);
    }
    if ($$self.$$.dirty & /*$root*/
    8192) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    4100) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    dispatch,
    $$restProps,
    checked,
    disabled,
    name27,
    required,
    value,
    onCheckedChange,
    attrs,
    $root,
    $$scope,
    slots,
    button_binding
  ];
}
var Checkbox = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance32, create_fragment32, safe_not_equal, {
      checked: 6,
      disabled: 7,
      name: 8,
      required: 9,
      value: 10,
      onCheckedChange: 11,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Checkbox",
      options,
      id: create_fragment32.name
    });
  }
  get checked() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set checked(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get name() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set name(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get required() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set required(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onCheckedChange() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onCheckedChange(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var checkbox_default = Checkbox;

// node_modules/bits-ui/dist/bits/checkbox/components/checkbox-indicator.svelte
var file32 = "node_modules/bits-ui/dist/bits/checkbox/components/checkbox-indicator.svelte";
var get_default_slot_changes_128 = (dirty) => ({
  attrs: dirty & /*attrs*/
  4,
  isChecked: dirty & /*$isChecked*/
  8,
  isIndeterminate: dirty & /*$isIndeterminate*/
  16
});
var get_default_slot_context_128 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[2]
  ),
  isChecked: (
    /*$isChecked*/
    ctx[3]
  ),
  isIndeterminate: (
    /*$isIndeterminate*/
    ctx[4]
  )
});
var get_default_slot_changes31 = (dirty) => ({
  attrs: dirty & /*attrs*/
  4,
  isChecked: dirty & /*$isChecked*/
  8,
  isIndeterminate: dirty & /*$isIndeterminate*/
  16
});
var get_default_slot_context31 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[2]
  ),
  isChecked: (
    /*$isChecked*/
    ctx[3]
  ),
  isIndeterminate: (
    /*$isIndeterminate*/
    ctx[4]
  )
});
function create_else_block28(ctx) {
  let div;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_128
  );
  let div_levels = [
    /*$$restProps*/
    ctx[8],
    /*attrs*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file32, 25, 1, 547);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[12](div);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs, $isChecked, $isIndeterminate*/
        1052)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_128
            ),
            get_default_slot_context_128
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*$$restProps*/
        256 && /*$$restProps*/
        ctx2[8],
        dirty & /*attrs*/
        4 && /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block28.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block31(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context31
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs, $isChecked, $isIndeterminate*/
        1052)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes31
            ),
            get_default_slot_context31
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block31.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment33(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block31, create_else_block28];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment33.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function getStateAttr(state) {
  if (state === "indeterminate") return "indeterminate";
  if (state) return "checked";
  return "unchecked";
}
function instance33($$self, $$props, $$invalidate) {
  let attrs;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $checked;
  let $isChecked;
  let $isIndeterminate;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Checkbox_indicator", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { helpers: { isChecked, isIndeterminate }, states: { checked }, getAttrs: getAttrs2 } = getCtx5();
  validate_store(isChecked, "isChecked");
  component_subscribe($$self, isChecked, (value) => $$invalidate(3, $isChecked = value));
  validate_store(isIndeterminate, "isIndeterminate");
  component_subscribe($$self, isIndeterminate, (value) => $$invalidate(4, $isIndeterminate = value));
  validate_store(checked, "checked");
  component_subscribe($$self, checked, (value) => $$invalidate(9, $checked = value));
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(8, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx5,
    asChild,
    el,
    isChecked,
    isIndeterminate,
    checked,
    getAttrs: getAttrs2,
    getStateAttr,
    attrs,
    $checked,
    $isChecked,
    $isIndeterminate
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(2, attrs = $$new_props.attrs);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$checked*/
    512) {
      $: $$invalidate(2, attrs = {
        ...getAttrs2("indicator"),
        "data-state": getStateAttr($checked)
      });
    }
  };
  return [
    el,
    asChild,
    attrs,
    $isChecked,
    $isIndeterminate,
    isChecked,
    isIndeterminate,
    checked,
    $$restProps,
    $checked,
    $$scope,
    slots,
    div_binding
  ];
}
var Checkbox_indicator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance33, create_fragment33, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Checkbox_indicator",
      options,
      id: create_fragment33.name
    });
  }
  get asChild() {
    throw new Error("<Checkbox_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Checkbox_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Checkbox_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Checkbox_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var checkbox_indicator_default = Checkbox_indicator;

// node_modules/bits-ui/dist/bits/checkbox/components/checkbox-input.svelte
var file33 = "node_modules/bits-ui/dist/bits/checkbox/components/checkbox-input.svelte";
function create_fragment34(ctx) {
  let input_1;
  let input_1_value_value;
  let $input_action_action;
  let mounted;
  let dispose;
  let input_1_levels = [
    /*$input*/
    ctx[1],
    {
      value: input_1_value_value = /*$value*/
      ctx[2] ?? "on"
    },
    /*$$restProps*/
    ctx[5]
  ];
  let input_data = {};
  for (let i = 0; i < input_1_levels.length; i += 1) {
    input_data = assign(input_data, input_1_levels[i]);
  }
  const block = {
    c: function create() {
      input_1 = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input_1 = claim_element(nodes, "INPUT", {});
      this.h();
    },
    h: function hydrate() {
      set_attributes(input_1, input_data);
      add_location(input_1, file33, 9, 0, 185);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input_1, anchor);
      if ("value" in input_data) {
        input_1.value = input_data.value;
      }
      if (input_1.autofocus) input_1.focus();
      ctx[6](input_1);
      if (!mounted) {
        dispose = action_destroyer($input_action_action = /*$input*/
        ctx[1].action(input_1));
        mounted = true;
      }
    },
    p: function update(ctx2, [dirty]) {
      set_attributes(input_1, input_data = get_spread_update(input_1_levels, [
        dirty & /*$input*/
        2 && /*$input*/
        ctx2[1],
        dirty & /*$value*/
        4 && input_1_value_value !== (input_1_value_value = /*$value*/
        ctx2[2] ?? "on") && input_1.value !== input_1_value_value && { value: input_1_value_value },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
      if ("value" in input_data) {
        input_1.value = input_data.value;
      }
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input_1);
      }
      ctx[6](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment34.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance34($$self, $$props, $$invalidate) {
  const omit_props_names = ["el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $input;
  let $value;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Checkbox_input", slots, []);
  let { el = void 0 } = $$props;
  const { elements: { input }, options: { value } } = getCtx5();
  validate_store(input, "input");
  component_subscribe($$self, input, (value2) => $$invalidate(1, $input = value2));
  validate_store(value, "value");
  component_subscribe($$self, value, (value2) => $$invalidate(2, $value = value2));
  function input_1_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx5,
    el,
    input,
    value,
    $input,
    $value
  });
  $$self.$inject_state = ($$new_props) => {
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, $input, $value, input, value, $$restProps, input_1_binding];
}
var Checkbox_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance34, create_fragment34, safe_not_equal, { el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Checkbox_input",
      options,
      id: create_fragment34.name
    });
  }
  get el() {
    throw new Error("<Checkbox_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Checkbox_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var checkbox_input_default = Checkbox_input;

// node_modules/bits-ui/dist/bits/collapsible/index.js
var collapsible_exports = {};
__export(collapsible_exports, {
  Content: () => collapsible_content_default,
  Root: () => collapsible_default,
  Trigger: () => collapsible_trigger_default
});

// node_modules/bits-ui/dist/bits/collapsible/ctx.js
function getCollapsibleData() {
  const NAME = "collapsible";
  const PARTS = ["root", "content", "trigger"];
  return {
    NAME,
    PARTS
  };
}
function setCtx6(props) {
  const { NAME, PARTS } = getCollapsibleData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const collapsible = { ...createCollapsible(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, collapsible);
  return {
    ...collapsible,
    updateOption: getOptionUpdater(collapsible.options)
  };
}
function getCtx6() {
  const { NAME } = getCollapsibleData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/collapsible/components/collapsible.svelte
var file34 = "node_modules/bits-ui/dist/bits/collapsible/components/collapsible.svelte";
var get_default_slot_changes_129 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_129 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes32 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context32 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block29(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_129
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file34, 38, 1, 747);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_129
            ),
            get_default_slot_context_129
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block29.name,
    type: "else",
    source: "(38:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block32(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context32
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes32
            ),
            get_default_slot_context32
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block32.name,
    type: "if",
    source: "(36:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment35(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block32, create_else_block29];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment35.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance35($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["disabled", "open", "onOpenChange", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Collapsible", slots, ["default"]);
  let { disabled = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { open: localOpen }, updateOption, getAttrs: getAttrs2 } = setCtx6({
    disabled,
    forceVisible: true,
    defaultOpen: open,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(5, open = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value) => $$invalidate(8, $root = value));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("disabled" in $$new_props) $$invalidate(6, disabled = $$new_props.disabled);
    if ("open" in $$new_props) $$invalidate(5, open = $$new_props.open);
    if ("onOpenChange" in $$new_props) $$invalidate(7, onOpenChange = $$new_props.onOpenChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx6,
    disabled,
    open,
    onOpenChange,
    asChild,
    el,
    root,
    localOpen,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("disabled" in $$props) $$invalidate(6, disabled = $$new_props.disabled);
    if ("open" in $$props) $$invalidate(5, open = $$new_props.open);
    if ("onOpenChange" in $$props) $$invalidate(7, onOpenChange = $$new_props.onOpenChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    32) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*disabled*/
    64) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*$root*/
    256) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    $$restProps,
    open,
    disabled,
    onOpenChange,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Collapsible = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance35, create_fragment35, safe_not_equal, {
      disabled: 6,
      open: 5,
      onOpenChange: 7,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Collapsible",
      options,
      id: create_fragment35.name
    });
  }
  get disabled() {
    throw new Error("<Collapsible>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Collapsible>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Collapsible>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Collapsible>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Collapsible>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Collapsible>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Collapsible>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Collapsible>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Collapsible>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Collapsible>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var collapsible_default = Collapsible;

// node_modules/bits-ui/dist/bits/collapsible/components/collapsible-content.svelte
var file35 = "node_modules/bits-ui/dist/bits/collapsible/components/collapsible-content.svelte";
var get_default_slot_changes_53 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_53 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_43 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_43 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_33 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_33 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_23 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_23 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_130 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context_130 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes33 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context33 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_54(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_53
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file35, 47, 1, 1357);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[20](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes_53
            ),
            get_default_slot_context_53
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[20](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_54.name,
    type: "if",
    source: "(47:16) ",
    ctx
  });
  return block;
}
function create_if_block_44(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_43
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file35, 43, 1, 1200);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[19](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[14],
              dirty,
              get_default_slot_changes_43
            ),
            get_default_slot_context_43
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[19](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_44.name,
    type: "if",
    source: "(43:33) ",
    ctx
  });
  return block;
}
function create_if_block_34(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_33
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file35, 39, 1, 1029);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[18](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[14],
              dirty,
              get_default_slot_changes_33
            ),
            get_default_slot_context_33
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[18](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_34.name,
    type: "if",
    source: "(39:32) ",
    ctx
  });
  return block;
}
function create_if_block_24(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_23
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file35, 29, 1, 807);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[17](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[14],
              dirty,
              get_default_slot_changes_23
            ),
            get_default_slot_context_23
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[17](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_24.name,
    type: "if",
    source: "(29:49) ",
    ctx
  });
  return block;
}
function create_if_block_14(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_130
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file35, 25, 1, 616);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[16](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[14],
              dirty,
              get_default_slot_changes_130
            ),
            get_default_slot_context_130
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[16](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_14.name,
    type: "if",
    source: "(25:30) ",
    ctx
  });
  return block;
}
function create_if_block33(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context33
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes33
            ),
            get_default_slot_context33
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block33.name,
    type: "if",
    source: "(23:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment36(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block33,
    create_if_block_14,
    create_if_block_24,
    create_if_block_34,
    create_if_block_44,
    create_if_block_54
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, -1))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment36.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance36($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Collapsible_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, getAttrs: getAttrs2 } = getCtx6();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(13, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getAttrs2("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(14, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx6,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    el,
    content,
    open,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $content,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$content*/
    8192) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    $$restProps,
    $content,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Collapsible_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance36, create_fragment36, safe_not_equal, {
      transition: 1,
      transitionConfig: 2,
      inTransition: 3,
      inTransitionConfig: 4,
      outTransition: 5,
      outTransitionConfig: 6,
      asChild: 7,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Collapsible_content",
      options,
      id: create_fragment36.name
    });
  }
  get transition() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Collapsible_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Collapsible_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var collapsible_content_default = Collapsible_content;

// node_modules/bits-ui/dist/bits/collapsible/components/collapsible-trigger.svelte
var file36 = "node_modules/bits-ui/dist/bits/collapsible/components/collapsible-trigger.svelte";
var get_default_slot_changes_131 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_131 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes34 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context34 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block30(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_131
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file36, 20, 1, 445);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_131
            ),
            get_default_slot_context_131
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block30.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block34(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context34
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes34
            ),
            get_default_slot_context34
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block34.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment37(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block34, create_else_block30];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment37.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance37($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Collapsible_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, getAttrs: getAttrs2 } = getCtx6();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(6, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    createDispatcher,
    getCtx: getCtx6,
    asChild,
    el,
    trigger,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$trigger*/
    64) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Collapsible_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance37, create_fragment37, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Collapsible_trigger",
      options,
      id: create_fragment37.name
    });
  }
  get asChild() {
    throw new Error("<Collapsible_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Collapsible_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Collapsible_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Collapsible_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var collapsible_trigger_default = Collapsible_trigger;

// node_modules/bits-ui/dist/bits/combobox/index.js
var combobox_exports = {};
__export(combobox_exports, {
  Arrow: () => combobox_arrow_default,
  Content: () => combobox_content_default,
  Group: () => combobox_group_default,
  GroupLabel: () => combobox_group_label_default,
  HiddenInput: () => combobox_hidden_input_default,
  Input: () => combobox_input_default,
  Item: () => combobox_item_default,
  ItemIndicator: () => combobox_item_indicator_default,
  Label: () => combobox_label_default,
  Root: () => combobox_default,
  Separator: () => separator_default
});

// node_modules/bits-ui/dist/bits/floating/helpers.js
function getPositioningUpdater(store) {
  return (props = {}) => {
    return updatePositioning(store, props);
  };
}
function updatePositioning(store, props) {
  const defaultPositioningProps = {
    side: "bottom",
    align: "center",
    sideOffset: 0,
    alignOffset: 0,
    sameWidth: false,
    avoidCollisions: true,
    collisionPadding: 8,
    fitViewport: false,
    strategy: "absolute",
    overlap: false
  };
  const withDefaults = { ...defaultPositioningProps, ...props };
  store.update((prev2) => {
    return {
      ...prev2,
      placement: joinPlacement(withDefaults.side, withDefaults.align),
      offset: {
        ...prev2.offset,
        mainAxis: withDefaults.sideOffset,
        crossAxis: withDefaults.alignOffset
      },
      gutter: 0,
      sameWidth: withDefaults.sameWidth,
      flip: withDefaults.avoidCollisions,
      overflowPadding: withDefaults.collisionPadding,
      boundary: withDefaults.collisionBoundary,
      fitViewport: withDefaults.fitViewport,
      strategy: withDefaults.strategy,
      overlap: withDefaults.overlap
    };
  });
}
function joinPlacement(side, align) {
  if (align === "center")
    return side;
  return `${side}-${align}`;
}

// node_modules/bits-ui/dist/bits/combobox/ctx.js
function getSelectData() {
  const NAME = "combobox";
  const GROUP_NAME = "combobox-group";
  const ITEM_NAME = "combobox-item";
  const PARTS = [
    "content",
    "menu",
    "input",
    "item",
    "label",
    "group",
    "group-label",
    "arrow",
    "hidden-input",
    "indicator"
  ];
  return {
    NAME,
    GROUP_NAME,
    ITEM_NAME,
    PARTS
  };
}
function getCtx7() {
  const { NAME } = getSelectData();
  return getContext(NAME);
}
function setCtx7(props) {
  const { NAME, PARTS } = getSelectData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const combobox = {
    ...createCombobox({ ...removeUndefined2(props), forceVisible: true }),
    getAttrs: getAttrs2
  };
  setContext(NAME, combobox);
  return {
    ...combobox,
    updateOption: getOptionUpdater(combobox.options)
  };
}
function setGroupCtx() {
  const { GROUP_NAME } = getSelectData();
  const id = generateId2();
  setContext(GROUP_NAME, id);
  const { elements: { group }, getAttrs: getAttrs2 } = getCtx7();
  return { group, id, getAttrs: getAttrs2 };
}
function setItemCtx(value) {
  const { ITEM_NAME } = getSelectData();
  const combobox = getCtx7();
  setContext(ITEM_NAME, value);
  return combobox;
}
function getGroupLabel() {
  const { GROUP_NAME } = getSelectData();
  const id = getContext(GROUP_NAME);
  const { elements: { groupLabel }, getAttrs: getAttrs2 } = getCtx7();
  return { groupLabel, id, getAttrs: getAttrs2 };
}
function getItemIndicator() {
  const { ITEM_NAME } = getSelectData();
  const { helpers: { isSelected }, getAttrs: getAttrs2 } = getCtx7();
  const value = getContext(ITEM_NAME);
  return {
    value,
    isSelected,
    getAttrs: getAttrs2
  };
}
function setArrow(size3 = 8) {
  var _a;
  const combobox = getCtx7();
  (_a = combobox.options.arrowSize) == null ? void 0 : _a.set(size3);
  return combobox;
}
function updatePositioning2(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "center",
    sameWidth: true
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx7();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/combobox/components/combobox.svelte
var get_default_slot_changes35 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context35 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment38(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[23].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[22],
    get_default_slot_context35
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        4194305)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[22],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[22]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[22],
              dirty,
              get_default_slot_changes35
            ),
            get_default_slot_context35
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment38.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance38($$self, $$props, $$invalidate) {
  let $localInputValue;
  let $touchedInput;
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox", slots, ["default"]);
  let { required = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { preventScroll = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { closeOnOutsideClick = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { name: name27 = void 0 } = $$props;
  let { multiple = false } = $$props;
  let { selected = void 0 } = $$props;
  let { onSelectedChange = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { items = [] } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  let { inputValue = "" } = $$props;
  const { states: { open: localOpen, selected: localSelected, inputValue: localInputValue, touchedInput }, updateOption, ids } = setCtx7({
    required,
    disabled,
    preventScroll,
    loop,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    name: name27,
    onOutsideClick,
    multiple,
    forceVisible: true,
    defaultSelected: Array.isArray(selected) ? [...selected] : (
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      selected
    ),
    defaultOpen: open,
    onSelectedChange: ({ next: next2 }) => {
      if (Array.isArray(next2)) {
        if (!Array.isArray(selected) || !arraysAreEqual(selected, next2)) {
          onSelectedChange == null ? void 0 : onSelectedChange(next2);
          $$invalidate(4, selected = next2);
          return next2;
        }
        return next2;
      }
      if (selected !== next2) {
        onSelectedChange == null ? void 0 : onSelectedChange(next2);
        $$invalidate(4, selected = next2);
      }
      $$invalidate(6, inputValue = (next2 == null ? void 0 : next2.label) ?? (typeof (next2 == null ? void 0 : next2.value) === "string" ? next2 == null ? void 0 : next2.value : ""));
      localInputValue.set(inputValue);
      return next2;
    },
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(5, open = next2);
      }
      return next2;
    },
    items
  });
  validate_store(localInputValue, "localInputValue");
  component_subscribe($$self, localInputValue, (value) => $$invalidate(20, $localInputValue = value));
  validate_store(touchedInput, "touchedInput");
  component_subscribe($$self, touchedInput, (value) => $$invalidate(21, $touchedInput = value));
  const idValues = derived([ids.menu, ids.trigger, ids.label], ([$menuId, $triggerId, $labelId]) => ({
    menu: $menuId,
    trigger: $triggerId,
    label: $labelId
  }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "required",
    "disabled",
    "preventScroll",
    "loop",
    "closeOnEscape",
    "closeOnOutsideClick",
    "portal",
    "name",
    "multiple",
    "selected",
    "onSelectedChange",
    "open",
    "onOpenChange",
    "items",
    "onOutsideClick",
    "inputValue"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Combobox> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("required" in $$props2) $$invalidate(7, required = $$props2.required);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("preventScroll" in $$props2) $$invalidate(9, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(10, loop = $$props2.loop);
    if ("closeOnEscape" in $$props2) $$invalidate(11, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(12, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(13, portal = $$props2.portal);
    if ("name" in $$props2) $$invalidate(14, name27 = $$props2.name);
    if ("multiple" in $$props2) $$invalidate(15, multiple = $$props2.multiple);
    if ("selected" in $$props2) $$invalidate(4, selected = $$props2.selected);
    if ("onSelectedChange" in $$props2) $$invalidate(16, onSelectedChange = $$props2.onSelectedChange);
    if ("open" in $$props2) $$invalidate(5, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(17, onOpenChange = $$props2.onOpenChange);
    if ("items" in $$props2) $$invalidate(18, items = $$props2.items);
    if ("onOutsideClick" in $$props2) $$invalidate(19, onOutsideClick = $$props2.onOutsideClick);
    if ("inputValue" in $$props2) $$invalidate(6, inputValue = $$props2.inputValue);
    if ("$$scope" in $$props2) $$invalidate(22, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    arraysAreEqual,
    derived,
    setCtx: setCtx7,
    required,
    disabled,
    preventScroll,
    loop,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    name: name27,
    multiple,
    selected,
    onSelectedChange,
    open,
    onOpenChange,
    items,
    onOutsideClick,
    inputValue,
    localOpen,
    localSelected,
    localInputValue,
    touchedInput,
    updateOption,
    ids,
    idValues,
    $localInputValue,
    $touchedInput,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("required" in $$props2) $$invalidate(7, required = $$props2.required);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("preventScroll" in $$props2) $$invalidate(9, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(10, loop = $$props2.loop);
    if ("closeOnEscape" in $$props2) $$invalidate(11, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(12, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(13, portal = $$props2.portal);
    if ("name" in $$props2) $$invalidate(14, name27 = $$props2.name);
    if ("multiple" in $$props2) $$invalidate(15, multiple = $$props2.multiple);
    if ("selected" in $$props2) $$invalidate(4, selected = $$props2.selected);
    if ("onSelectedChange" in $$props2) $$invalidate(16, onSelectedChange = $$props2.onSelectedChange);
    if ("open" in $$props2) $$invalidate(5, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(17, onOpenChange = $$props2.onOpenChange);
    if ("items" in $$props2) $$invalidate(18, items = $$props2.items);
    if ("onOutsideClick" in $$props2) $$invalidate(19, onOutsideClick = $$props2.onOutsideClick);
    if ("inputValue" in $$props2) $$invalidate(6, inputValue = $$props2.inputValue);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$touchedInput, $localInputValue*/
    3145728) {
      $: if ($touchedInput) $$invalidate(6, inputValue = $localInputValue);
    }
    if ($$self.$$.dirty & /*inputValue*/
    64) {
      $: inputValue !== void 0 && localInputValue.set(inputValue);
    }
    if ($$self.$$.dirty & /*open*/
    32) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*selected*/
    16) {
      $: selected !== void 0 && localSelected.set(Array.isArray(selected) ? [...selected] : (
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        selected
      ));
    }
    if ($$self.$$.dirty & /*required*/
    128) {
      $: updateOption("required", required);
    }
    if ($$self.$$.dirty & /*disabled*/
    256) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    512) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*loop*/
    1024) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    2048) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    4096) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*portal*/
    8192) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*name*/
    16384) {
      $: updateOption("name", name27);
    }
    if ($$self.$$.dirty & /*multiple*/
    32768) {
      $: updateOption("multiple", multiple);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    524288) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    localInputValue,
    touchedInput,
    idValues,
    selected,
    open,
    inputValue,
    required,
    disabled,
    preventScroll,
    loop,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    name27,
    multiple,
    onSelectedChange,
    onOpenChange,
    items,
    onOutsideClick,
    $localInputValue,
    $touchedInput,
    $$scope,
    slots
  ];
}
var Combobox = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance38, create_fragment38, safe_not_equal, {
      required: 7,
      disabled: 8,
      preventScroll: 9,
      loop: 10,
      closeOnEscape: 11,
      closeOnOutsideClick: 12,
      portal: 13,
      name: 14,
      multiple: 15,
      selected: 4,
      onSelectedChange: 16,
      open: 5,
      onOpenChange: 17,
      items: 18,
      onOutsideClick: 19,
      inputValue: 6
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox",
      options,
      id: create_fragment38.name
    });
  }
  get required() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set required(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventScroll() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnOutsideClick() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get name() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set name(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get multiple() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set multiple(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get selected() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set selected(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onSelectedChange() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onSelectedChange(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get items() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set items(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inputValue() {
    throw new Error("<Combobox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inputValue(value) {
    throw new Error("<Combobox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_default = Combobox;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-content.svelte
var file37 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-content.svelte";
var get_default_slot_changes_54 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_54 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_44 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_44 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_34 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_34 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_24 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_24 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_132 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_132 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes36 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context36 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_55(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[26].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[25],
    get_default_slot_context_54
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file37, 100, 1, 2315);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[35](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_4*/
            ctx[31],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33554688)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[25],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[25]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[25],
              dirty,
              get_default_slot_changes_54
            ),
            get_default_slot_context_54
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[35](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_55.name,
    type: "if",
    source: "(100:16) ",
    ctx
  });
  return block;
}
function create_if_block_45(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[26].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[25],
    get_default_slot_context_44
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file37, 89, 1, 2104);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[34](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_3*/
            ctx[30],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33554688)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[25],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[25]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[25],
              dirty,
              get_default_slot_changes_44
            ),
            get_default_slot_context_44
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[34](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_45.name,
    type: "if",
    source: "(89:33) ",
    ctx
  });
  return block;
}
function create_if_block_35(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[26].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[25],
    get_default_slot_context_34
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file37, 79, 1, 1896);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_2*/
            ctx[29],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33554688)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[25],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[25]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[25],
              dirty,
              get_default_slot_changes_34
            ),
            get_default_slot_context_34
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_35.name,
    type: "if",
    source: "(79:32) ",
    ctx
  });
  return block;
}
function create_if_block_25(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[26].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[25],
    get_default_slot_context_24
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file37, 67, 1, 1630);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[33](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_1*/
            ctx[28],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33554688)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[25],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[25]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[25],
              dirty,
              get_default_slot_changes_24
            ),
            get_default_slot_context_24
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[33](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_25.name,
    type: "if",
    source: "(67:49) ",
    ctx
  });
  return block;
}
function create_if_block_15(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[26].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[25],
    get_default_slot_context_132
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file37, 56, 1, 1385);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler*/
            ctx[27],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33554688)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[25],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[25]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[25],
              dirty,
              get_default_slot_changes_132
            ),
            get_default_slot_context_132
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_15.name,
    type: "if",
    source: "(56:30) ",
    ctx
  });
  return block;
}
function create_if_block35(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[26].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[25],
    get_default_slot_context36
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33554688)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[25],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[25]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[25],
              dirty,
              get_default_slot_changes36
            ),
            get_default_slot_context36
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block35.name,
    type: "if",
    source: "(54:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment39(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block35,
    create_if_block_15,
    create_if_block_25,
    create_if_block_35,
    create_if_block_45,
    create_if_block_55
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment39.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance39($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $open;
  let $menu;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "bottom" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = true } = $$props;
  let { fitViewport = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { menu }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx7();
  validate_store(menu, "menu");
  component_subscribe($$self, menu, (value) => $$invalidate(24, $menu = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("content");
  function keydown_handler(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(25, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    melt,
    getCtx: getCtx7,
    updatePositioning: updatePositioning2,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    el,
    menu,
    open,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $open,
    $menu
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    16384) {
      $: if (id) {
        ids.menu.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$menu*/
    16777216) {
      $: $$invalidate(8, builder = $menu);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*$open, side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport*/
    16744960) {
      $: if ($open) updatePositioning2({
        side,
        align,
        sideOffset,
        alignOffset,
        collisionPadding,
        avoidCollisions,
        collisionBoundary,
        sameWidth,
        fitViewport
      });
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    menu,
    open,
    dispatch,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    $menu,
    $$scope,
    slots,
    keydown_handler,
    keydown_handler_1,
    keydown_handler_2,
    keydown_handler_3,
    keydown_handler_4,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3
  ];
}
var Combobox_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance39,
      create_fragment39,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 14,
        side: 15,
        align: 16,
        sideOffset: 17,
        alignOffset: 18,
        collisionPadding: 19,
        avoidCollisions: 20,
        collisionBoundary: 21,
        sameWidth: 22,
        fitViewport: 23,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_content",
      options,
      id: create_fragment39.name
    });
  }
  get transition() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_content_default = Combobox_content;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-input.svelte
var file38 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-input.svelte";
var get_default_slot_changes37 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  placeholder: dirty & /*placeholder*/
  4
});
var get_default_slot_context37 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  placeholder: (
    /*placeholder*/
    ctx[2]
  )
});
function create_else_block31(ctx) {
  let input_1;
  let builder_action_action;
  let mounted;
  let dispose;
  let input_1_levels = [
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[6],
    { placeholder: (
      /*placeholder*/
      ctx[2]
    ) }
  ];
  let input_data = {};
  for (let i = 0; i < input_1_levels.length; i += 1) {
    input_data = assign(input_data, input_1_levels[i]);
  }
  const block = {
    c: function create() {
      input_1 = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input_1 = claim_element(nodes, "INPUT", { placeholder: true });
      this.h();
    },
    h: function hydrate() {
      set_attributes(input_1, input_data);
      add_location(input_1, file38, 21, 1, 486);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input_1, anchor);
      if (input_1.autofocus) input_1.focus();
      ctx[10](input_1);
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[3].action(input_1)),
          listen_dev(
            input_1,
            "m-click",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            input_1,
            "m-keydown",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            input_1,
            "m-input",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(input_1, input_data = get_spread_update(input_1_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6],
        dirty & /*placeholder*/
        4 && { placeholder: (
          /*placeholder*/
          ctx2[2]
        ) }
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input_1);
      }
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block31.name,
    type: "else",
    source: "(21:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block36(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context37
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, placeholder*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes37
            ),
            get_default_slot_context37
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block36.name,
    type: "if",
    source: "(19:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment40(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block36, create_else_block31];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment40.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance40($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "placeholder", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $input;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { placeholder = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { input }, getAttrs: getAttrs2 } = getCtx7();
  validate_store(input, "input");
  component_subscribe($$self, input, (value) => $$invalidate(7, $input = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("input");
  function input_1_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("placeholder" in $$new_props) $$invalidate(2, placeholder = $$new_props.placeholder);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx7,
    createDispatcher,
    asChild,
    placeholder,
    el,
    input,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $input
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("placeholder" in $$props) $$invalidate(2, placeholder = $$new_props.placeholder);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$input*/
    128) {
      $: $$invalidate(3, builder = $input);
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    placeholder,
    builder,
    input,
    dispatch,
    $$restProps,
    $input,
    $$scope,
    slots,
    input_1_binding
  ];
}
var Combobox_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance40, create_fragment40, safe_not_equal, { asChild: 1, placeholder: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_input",
      options,
      id: create_fragment40.name
    });
  }
  get asChild() {
    throw new Error("<Combobox_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get placeholder() {
    throw new Error("<Combobox_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Combobox_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_input_default = Combobox_input;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-item.svelte
var file39 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-item.svelte";
var get_default_slot_changes_133 = (dirty) => ({
  builder: dirty & /*builder*/
  16,
  isSelected: dirty & /*isSelected*/
  32
});
var get_default_slot_context_133 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[4]
  ),
  isSelected: (
    /*isSelected*/
    ctx[5]
  )
});
var get_default_slot_changes38 = (dirty) => ({
  builder: dirty & /*builder*/
  16,
  isSelected: dirty & /*isSelected*/
  32
});
var get_default_slot_context38 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[4]
  ),
  isSelected: (
    /*isSelected*/
    ctx[5]
  )
});
function create_else_block32(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[14].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[13],
    get_default_slot_context_133
  );
  const default_slot_or_fallback = default_slot || fallback_block3(ctx);
  let div_levels = [
    /*builder*/
    ctx[4],
    /*$$restProps*/
    ctx[9]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file39, 31, 1, 812);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[19](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[4].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[8],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[8],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "focusin",
            /*focusin_handler*/
            ctx[15],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler*/
            ctx[16],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "focusout",
            /*focusout_handler*/
            ctx[17],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerleave",
            /*pointerleave_handler*/
            ctx[18],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, isSelected*/
        8240)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[13],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[13]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[13],
              dirty,
              get_default_slot_changes_133
            ),
            get_default_slot_context_133
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*label, value*/
        5)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        16 && /*builder*/
        ctx2[4],
        dirty & /*$$restProps*/
        512 && /*$$restProps*/
        ctx2[9]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[19](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block32.name,
    type: "else",
    source: "(31:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block37(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[14].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[13],
    get_default_slot_context38
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, isSelected*/
        8240)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[13],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[13]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[13],
              dirty,
              get_default_slot_changes38
            ),
            get_default_slot_context38
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block37.name,
    type: "if",
    source: "(29:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block3(ctx) {
  let t_value = (
    /*label*/
    (ctx[0] ? (
      /*label*/
      ctx[0]
    ) : (
      /*value*/
      ctx[2]
    )) + ""
  );
  let t;
  const block = {
    c: function create() {
      t = text(t_value);
    },
    l: function claim(nodes) {
      t = claim_text(nodes, t_value);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*label, value*/
      5 && t_value !== (t_value = /*label*/
      (ctx2[0] ? (
        /*label*/
        ctx2[0]
      ) : (
        /*value*/
        ctx2[2]
      )) + "")) set_data_dev(t, t_value);
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block3.name,
    type: "fallback",
    source: "(43:31)     ",
    ctx
  });
  return block;
}
function create_fragment41(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block37, create_else_block32];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[3]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment41.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance41($$self, $$props, $$invalidate) {
  let builder;
  let isSelected;
  const omit_props_names = ["value", "disabled", "label", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isSelectedStore;
  let $item;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_item", slots, ["default"]);
  let { value } = $$props;
  let { disabled = void 0 } = $$props;
  let { label = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { option: item }, helpers: { isSelected: isSelectedStore }, getAttrs: getAttrs2 } = setItemCtx(value);
  validate_store(item, "item");
  component_subscribe($$self, item, (value2) => $$invalidate(12, $item = value2));
  validate_store(isSelectedStore, "isSelectedStore");
  component_subscribe($$self, isSelectedStore, (value2) => $$invalidate(11, $isSelectedStore = value2));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("item");
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Combobox_item> was created without expected prop 'value'");
    }
  });
  function focusin_handler(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler(event) {
    bubble.call(this, $$self, event);
  }
  function focusout_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointerleave_handler(event) {
    bubble.call(this, $$self, event);
  }
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(1, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(9, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(2, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("label" in $$new_props) $$invalidate(0, label = $$new_props.label);
    if ("asChild" in $$new_props) $$invalidate(3, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(1, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(13, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setItemCtx,
    createDispatcher,
    value,
    disabled,
    label,
    asChild,
    el,
    item,
    isSelectedStore,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    isSelected,
    builder,
    $isSelectedStore,
    $item
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(2, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("label" in $$props) $$invalidate(0, label = $$new_props.label);
    if ("asChild" in $$props) $$invalidate(3, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(1, el = $$new_props.el);
    if ("isSelected" in $$props) $$invalidate(5, isSelected = $$new_props.isSelected);
    if ("builder" in $$props) $$invalidate(4, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*label, value*/
    5) {
      $: if (!label && typeof value === "string") $$invalidate(0, label = value);
    }
    if ($$self.$$.dirty & /*$item, value, disabled, label*/
    5125) {
      $: $$invalidate(4, builder = $item({ value, disabled, label }));
    }
    if ($$self.$$.dirty & /*builder*/
    16) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$isSelectedStore, value*/
    2052) {
      $: $$invalidate(5, isSelected = $isSelectedStore(value));
    }
  };
  return [
    label,
    el,
    value,
    asChild,
    builder,
    isSelected,
    item,
    isSelectedStore,
    dispatch,
    $$restProps,
    disabled,
    $isSelectedStore,
    $item,
    $$scope,
    slots,
    focusin_handler,
    keydown_handler,
    focusout_handler,
    pointerleave_handler,
    div_binding
  ];
}
var Combobox_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance41, create_fragment41, safe_not_equal, {
      value: 2,
      disabled: 10,
      label: 0,
      asChild: 3,
      el: 1
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_item",
      options,
      id: create_fragment41.name
    });
  }
  get value() {
    throw new Error("<Combobox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Combobox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Combobox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Combobox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get label() {
    throw new Error("<Combobox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set label(value) {
    throw new Error("<Combobox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Combobox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_item_default = Combobox_item;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-label.svelte
var file40 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-label.svelte";
var get_default_slot_changes39 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context39 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block33(ctx) {
  let label_1;
  let label_1_for_value;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    null
  );
  let label_1_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4],
    {
      for: label_1_for_value = /*builder*/
      ctx[2].id
    }
  ];
  let label_data = {};
  for (let i = 0; i < label_1_levels.length; i += 1) {
    label_data = assign(label_data, label_1_levels[i]);
  }
  const block = {
    c: function create() {
      label_1 = element("label");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      label_1 = claim_element(nodes, "LABEL", { for: true });
      var label_1_nodes = children(label_1);
      if (default_slot) default_slot.l(label_1_nodes);
      label_1_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(label_1, label_data);
      add_location(label_1, file40, 18, 1, 338);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, label_1, anchor);
      if (default_slot) {
        default_slot.m(label_1, null);
      }
      ctx[8](label_1);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(label_1));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        64)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(label_1, label_data = get_spread_update(label_1_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4],
        (!current || dirty & /*builder*/
        4 && label_1_for_value !== (label_1_for_value = /*builder*/
        ctx2[2].id)) && { for: label_1_for_value }
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(label_1);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block33.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block38(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context39
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes39
            ),
            get_default_slot_context39
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block38.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment42(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block38, create_else_block33];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment42.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance42($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $label;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { label }, getAttrs: getAttrs2 } = getCtx7();
  validate_store(label, "label");
  component_subscribe($$self, label, (value) => $$invalidate(5, $label = value));
  const attrs = getAttrs2("label");
  function label_1_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx7,
    asChild,
    el,
    label,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $label
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$label*/
    32) {
      $: $$invalidate(2, builder = $label);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    label,
    $$restProps,
    $label,
    $$scope,
    slots,
    label_1_binding
  ];
}
var Combobox_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance42, create_fragment42, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_label",
      options,
      id: create_fragment42.name
    });
  }
  get asChild() {
    throw new Error("<Combobox_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_label_default = Combobox_label;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-group.svelte
var file41 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-group.svelte";
var get_default_slot_changes_134 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_134 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes40 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context40 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block34(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_134
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file41, 15, 1, 338);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_134
            ),
            get_default_slot_context_134
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block34.name,
    type: "else",
    source: "(15:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block39(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context40
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes40
            ),
            get_default_slot_context40
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block39.name,
    type: "if",
    source: "(13:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment43(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block39, create_else_block34];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment43.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance43($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $group;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_group", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { group, id, getAttrs: getAttrs2 } = setGroupCtx();
  validate_store(group, "group");
  component_subscribe($$self, group, (value) => $$invalidate(5, $group = value));
  const attrs = getAttrs2("group");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setGroupCtx,
    asChild,
    el,
    group,
    id,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $group
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$group*/
    32) {
      $: $$invalidate(2, builder = $group(id));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, group, $$restProps, $group, $$scope, slots, div_binding];
}
var Combobox_group = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance43, create_fragment43, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_group",
      options,
      id: create_fragment43.name
    });
  }
  get asChild() {
    throw new Error("<Combobox_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_group_default = Combobox_group;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-group-label.svelte
var file42 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-group-label.svelte";
var get_default_slot_changes_135 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_135 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes41 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context41 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block35(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_135
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file42, 21, 1, 472);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[9](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_135
            ),
            get_default_slot_context_135
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block35.name,
    type: "else",
    source: "(21:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block40(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context41
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes41
            ),
            get_default_slot_context41
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block40.name,
    type: "if",
    source: "(19:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment44(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block40, create_else_block35];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment44.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance44($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $groupLabel;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_group_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { ids, getAttrs: getAttrs2 } = getCtx7();
  const { groupLabel, id: groupId } = getGroupLabel();
  validate_store(groupLabel, "groupLabel");
  component_subscribe($$self, groupLabel, (value) => $$invalidate(6, $groupLabel = value));
  const attrs = getAttrs2("group-label");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getGroupLabel,
    getCtx: getCtx7,
    asChild,
    id,
    el,
    ids,
    getAttrs: getAttrs2,
    groupLabel,
    groupId,
    attrs,
    builder,
    $groupLabel
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    32) {
      $: if (id) {
        ids.label.set(id);
      }
    }
    if ($$self.$$.dirty & /*$groupLabel*/
    64) {
      $: $$invalidate(2, builder = $groupLabel(groupId));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    groupLabel,
    $$restProps,
    id,
    $groupLabel,
    $$scope,
    slots,
    div_binding
  ];
}
var Combobox_group_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance44, create_fragment44, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_group_label",
      options,
      id: create_fragment44.name
    });
  }
  get asChild() {
    throw new Error("<Combobox_group_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_group_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Combobox_group_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Combobox_group_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_group_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_group_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_group_label_default = Combobox_group_label;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-arrow.svelte
var file43 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-arrow.svelte";
var get_default_slot_changes42 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context42 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block36(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file43, 19, 1, 367);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block36.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block41(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context42
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes42
            ),
            get_default_slot_context42
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block41.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment45(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block41, create_else_block36];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment45.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance45($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "size"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_arrow", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { size: size3 = 8 } = $$props;
  const { elements: { arrow: arrow3 }, getAttrs: getAttrs2 } = setArrow(size3);
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getAttrs2("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setArrow,
    asChild,
    el,
    size: size3,
    arrow: arrow3,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Combobox_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance45, create_fragment45, safe_not_equal, { asChild: 1, el: 0, size: 5 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_arrow",
      options,
      id: create_fragment45.name
    });
  }
  get asChild() {
    throw new Error("<Combobox_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get size() {
    throw new Error("<Combobox_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Combobox_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_arrow_default = Combobox_arrow;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-hidden-input.svelte
var file44 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-hidden-input.svelte";
var get_default_slot_changes43 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context43 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block37(ctx) {
  let input;
  let builder_action_action;
  let mounted;
  let dispose;
  let input_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let input_data = {};
  for (let i = 0; i < input_levels.length; i += 1) {
    input_data = assign(input_data, input_levels[i]);
  }
  const block = {
    c: function create() {
      input = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input = claim_element(nodes, "INPUT", {});
      this.h();
    },
    h: function hydrate() {
      set_attributes(input, input_data);
      add_location(input, file44, 23, 1, 428);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input, anchor);
      if (input.autofocus) input.focus();
      ctx[11](input);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(input));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(input, input_data = get_spread_update(input_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input);
      }
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block37.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block42(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context43
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes43
            ),
            get_default_slot_context43
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block42.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment46(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block42, create_else_block37];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment46.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance46($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $hiddenInput;
  let $disabled;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_hidden_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { hiddenInput }, options: { disabled }, getAttrs: getAttrs2 } = getCtx7();
  validate_store(hiddenInput, "hiddenInput");
  component_subscribe($$self, hiddenInput, (value) => $$invalidate(7, $hiddenInput = value));
  validate_store(disabled, "disabled");
  component_subscribe($$self, disabled, (value) => $$invalidate(8, $disabled = value));
  function input_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx7,
    asChild,
    el,
    hiddenInput,
    disabled,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $hiddenInput,
    $disabled
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(6, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$disabled*/
    256) {
      $: $$invalidate(6, attrs = {
        ...getAttrs2("input"),
        disabled: $disabled ? true : void 0
      });
    }
    if ($$self.$$.dirty & /*$hiddenInput*/
    128) {
      $: $$invalidate(2, builder = $hiddenInput);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    68) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    hiddenInput,
    disabled,
    $$restProps,
    attrs,
    $hiddenInput,
    $disabled,
    $$scope,
    slots,
    input_binding
  ];
}
var Combobox_hidden_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance46, create_fragment46, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_hidden_input",
      options,
      id: create_fragment46.name
    });
  }
  get asChild() {
    throw new Error("<Combobox_hidden_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_hidden_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_hidden_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_hidden_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_hidden_input_default = Combobox_hidden_input;

// node_modules/bits-ui/dist/bits/separator/ctx.js
function getSeparatorData() {
  const NAME = "separator";
  const PARTS = ["root"];
  return {
    NAME,
    PARTS
  };
}
function setCtx8(props) {
  const { NAME, PARTS } = getSeparatorData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const separator = { ...createSeparator(removeUndefined2(props)), getAttrs: getAttrs2 };
  return {
    ...separator,
    updateOption: getOptionUpdater(separator.options)
  };
}

// node_modules/bits-ui/dist/bits/separator/components/separator.svelte
var file45 = "node_modules/bits-ui/dist/bits/separator/components/separator.svelte";
var get_default_slot_changes44 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context44 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block38(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file45, 25, 1, 539);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[10](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block38.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block43(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context44
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes44
            ),
            get_default_slot_context44
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block43.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment47(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block43, create_else_block38];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment47.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance47($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["orientation", "decorative", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Separator", slots, ["default"]);
  let { orientation = "horizontal" } = $$props;
  let { decorative = true } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, updateOption, getAttrs: getAttrs2 } = setCtx8({ orientation, decorative });
  validate_store(root, "root");
  component_subscribe($$self, root, (value) => $$invalidate(7, $root = value));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("orientation" in $$new_props) $$invalidate(5, orientation = $$new_props.orientation);
    if ("decorative" in $$new_props) $$invalidate(6, decorative = $$new_props.decorative);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx8,
    orientation,
    decorative,
    asChild,
    el,
    root,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("orientation" in $$props) $$invalidate(5, orientation = $$new_props.orientation);
    if ("decorative" in $$props) $$invalidate(6, decorative = $$new_props.decorative);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*orientation*/
    32) {
      $: updateOption("orientation", orientation);
    }
    if ($$self.$$.dirty & /*decorative*/
    64) {
      $: updateOption("decorative", decorative);
    }
    if ($$self.$$.dirty & /*$root*/
    128) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    $$restProps,
    orientation,
    decorative,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Separator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance47, create_fragment47, safe_not_equal, {
      orientation: 5,
      decorative: 6,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Separator",
      options,
      id: create_fragment47.name
    });
  }
  get orientation() {
    throw new Error("<Separator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set orientation(value) {
    throw new Error("<Separator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get decorative() {
    throw new Error("<Separator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set decorative(value) {
    throw new Error("<Separator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Separator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Separator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Separator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Separator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var separator_default = Separator;

// node_modules/bits-ui/dist/bits/combobox/components/combobox-item-indicator.svelte
var file46 = "node_modules/bits-ui/dist/bits/combobox/components/combobox-item-indicator.svelte";
var get_default_slot_changes_136 = (dirty) => ({ isSelected: dirty & /*$isSelected*/
4 });
var get_default_slot_context_136 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[5]
  ),
  isSelected: (
    /*$isSelected*/
    ctx[2](
      /*value*/
      ctx[4]
    )
  )
});
var get_default_slot_changes45 = (dirty) => ({ isSelected: dirty & /*$isSelected*/
4 });
var get_default_slot_context45 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[5]
  ),
  isSelected: (
    /*$isSelected*/
    ctx[2](
      /*value*/
      ctx[4]
    )
  )
});
function create_else_block39(ctx) {
  let div;
  let show_if = (
    /*$isSelected*/
    ctx[2](
      /*value*/
      ctx[4]
    )
  );
  let current;
  let if_block = show_if && create_if_block_16(ctx);
  let div_levels = [
    /*$$restProps*/
    ctx[6],
    /*attrs*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (if_block) if_block.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (if_block) if_block.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file46, 10, 1, 287);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (if_block) if_block.m(div, null);
      ctx[9](div);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*$isSelected*/
      4) show_if = /*$isSelected*/
      ctx2[2](
        /*value*/
        ctx2[4]
      );
      if (show_if) {
        if (if_block) {
          if_block.p(ctx2, dirty);
          if (dirty & /*$isSelected*/
          4) {
            transition_in(if_block, 1);
          }
        } else {
          if_block = create_if_block_16(ctx2);
          if_block.c();
          transition_in(if_block, 1);
          if_block.m(div, null);
        }
      } else if (if_block) {
        group_outros();
        transition_out(if_block, 1, 1, () => {
          if_block = null;
        });
        check_outros();
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6],
        /*attrs*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (if_block) if_block.d();
      ctx[9](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block39.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block44(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context45
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $isSelected*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes45
            ),
            get_default_slot_context45
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block44.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_if_block_16(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_136
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $isSelected*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_136
            ),
            get_default_slot_context_136
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_16.name,
    type: "if",
    source: "(12:2) {#if $isSelected(value)}",
    ctx
  });
  return block;
}
function create_fragment48(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block44, create_else_block39];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment48.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance48($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isSelected;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Combobox_item_indicator", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { isSelected, value, getAttrs: getAttrs2 } = getItemIndicator();
  validate_store(isSelected, "isSelected");
  component_subscribe($$self, isSelected, (value2) => $$invalidate(2, $isSelected = value2));
  const attrs = getAttrs2("indicator");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getItemIndicator,
    asChild,
    el,
    isSelected,
    value,
    getAttrs: getAttrs2,
    attrs,
    $isSelected
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [
    el,
    asChild,
    $isSelected,
    isSelected,
    value,
    attrs,
    $$restProps,
    $$scope,
    slots,
    div_binding
  ];
}
var Combobox_item_indicator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance48, create_fragment48, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Combobox_item_indicator",
      options,
      id: create_fragment48.name
    });
  }
  get asChild() {
    throw new Error("<Combobox_item_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Combobox_item_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Combobox_item_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Combobox_item_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var combobox_item_indicator_default = Combobox_item_indicator;

// node_modules/bits-ui/dist/bits/context-menu/index.js
var context_menu_exports = {};
__export(context_menu_exports, {
  Arrow: () => menu_arrow_default,
  CheckboxIndicator: () => menu_checkbox_indicator_default,
  CheckboxItem: () => menu_checkbox_item_default,
  Content: () => context_menu_content_default,
  Group: () => menu_group_default,
  Item: () => menu_item_default,
  Label: () => menu_label_default,
  RadioGroup: () => menu_radio_group_default,
  RadioIndicator: () => menu_radio_indicator_default,
  RadioItem: () => menu_radio_item_default,
  Root: () => context_menu_default,
  Separator: () => menu_separator_default,
  Sub: () => menu_sub_default,
  SubContent: () => menu_sub_content_default,
  SubTrigger: () => menu_sub_trigger_default,
  Trigger: () => context_menu_trigger_default
});

// node_modules/bits-ui/dist/bits/context-menu/ctx.js
function getContextMenuData() {
  const NAME = "menu";
  const PARTS = [
    "arrow",
    "checkbox-indicator",
    "checkbox-item",
    "content",
    "group",
    "item",
    "label",
    "radio-group",
    "radio-item",
    "separator",
    "sub-content",
    "sub-trigger",
    "trigger"
  ];
  return {
    NAME,
    PARTS
  };
}
function setCtx9(props) {
  const { NAME, PARTS } = getContextMenuData();
  const getAttrs2 = createBitAttrs("menu", PARTS);
  const contextMenu = { ...createContextMenu(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, contextMenu);
  return {
    ...contextMenu,
    updateOption: getOptionUpdater(contextMenu.options)
  };
}
function getCtx8() {
  const { NAME } = getContextMenuData();
  return getContext(NAME);
}
function updatePositioning3(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "start"
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx8();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/context-menu/components/context-menu.svelte
var get_default_slot_changes46 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context46 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment49(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context46
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        16385)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes46
            ),
            get_default_slot_context46
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment49.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance49($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Context_menu", slots, ["default"]);
  let { closeOnOutsideClick = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { preventScroll = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { dir = void 0 } = $$props;
  let { typeahead = void 0 } = $$props;
  let { closeFocus = void 0 } = $$props;
  let { disableFocusFirstItem = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { open: localOpen }, updateOption, ids } = setCtx9({
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    forceVisible: true,
    defaultOpen: open,
    preventScroll,
    loop,
    dir,
    typeahead,
    disableFocusFirstItem,
    closeFocus,
    onOutsideClick,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.menu, ids.trigger], ([$menuId, $triggerId]) => ({ menu: $menuId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "closeOnOutsideClick",
    "closeOnEscape",
    "portal",
    "open",
    "onOpenChange",
    "preventScroll",
    "loop",
    "dir",
    "typeahead",
    "closeFocus",
    "disableFocusFirstItem",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Context_menu> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("closeOnOutsideClick" in $$props2) $$invalidate(3, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(5, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(6, onOpenChange = $$props2.onOpenChange);
    if ("preventScroll" in $$props2) $$invalidate(7, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(8, loop = $$props2.loop);
    if ("dir" in $$props2) $$invalidate(9, dir = $$props2.dir);
    if ("typeahead" in $$props2) $$invalidate(10, typeahead = $$props2.typeahead);
    if ("closeFocus" in $$props2) $$invalidate(11, closeFocus = $$props2.closeFocus);
    if ("disableFocusFirstItem" in $$props2) $$invalidate(12, disableFocusFirstItem = $$props2.disableFocusFirstItem);
    if ("onOutsideClick" in $$props2) $$invalidate(13, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(14, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    setCtx: setCtx9,
    derived,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    open,
    onOpenChange,
    preventScroll,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    onOutsideClick,
    localOpen,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("closeOnOutsideClick" in $$props2) $$invalidate(3, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(5, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(6, onOpenChange = $$props2.onOpenChange);
    if ("preventScroll" in $$props2) $$invalidate(7, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(8, loop = $$props2.loop);
    if ("dir" in $$props2) $$invalidate(9, dir = $$props2.dir);
    if ("typeahead" in $$props2) $$invalidate(10, typeahead = $$props2.typeahead);
    if ("closeFocus" in $$props2) $$invalidate(11, closeFocus = $$props2.closeFocus);
    if ("disableFocusFirstItem" in $$props2) $$invalidate(12, disableFocusFirstItem = $$props2.disableFocusFirstItem);
    if ("onOutsideClick" in $$props2) $$invalidate(13, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    8) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    16) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*portal*/
    32) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    128) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*loop*/
    256) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*dir*/
    512) {
      $: updateOption("dir", dir);
    }
    if ($$self.$$.dirty & /*closeFocus*/
    2048) {
      $: updateOption("closeFocus", closeFocus);
    }
    if ($$self.$$.dirty & /*disableFocusFirstItem*/
    4096) {
      $: updateOption("disableFocusFirstItem", disableFocusFirstItem);
    }
    if ($$self.$$.dirty & /*typeahead*/
    1024) {
      $: updateOption("typeahead", typeahead);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    8192) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    onOpenChange,
    preventScroll,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Context_menu = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance49, create_fragment49, safe_not_equal, {
      closeOnOutsideClick: 3,
      closeOnEscape: 4,
      portal: 5,
      open: 2,
      onOpenChange: 6,
      preventScroll: 7,
      loop: 8,
      dir: 9,
      typeahead: 10,
      closeFocus: 11,
      disableFocusFirstItem: 12,
      onOutsideClick: 13
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Context_menu",
      options,
      id: create_fragment49.name
    });
  }
  get closeOnOutsideClick() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventScroll() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get dir() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set dir(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get typeahead() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set typeahead(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeFocus() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeFocus(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disableFocusFirstItem() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disableFocusFirstItem(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Context_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Context_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var context_menu_default = Context_menu;

// node_modules/bits-ui/dist/bits/menu/ctx.js
function getMenuData() {
  const NAME = "menu";
  const SUB_NAME = "menu-submenu";
  const RADIO_GROUP_NAME = "menu-radiogroup";
  const CHECKBOX_ITEM_NAME = "menu-checkboxitem";
  const RADIO_ITEM_NAME = "menu-radioitem";
  const GROUP_NAME = "menu-group";
  const PARTS = [
    "arrow",
    "checkbox-indicator",
    "checkbox-item",
    "content",
    "group",
    "item",
    "label",
    "radio-group",
    "radio-item",
    "radio-indicator",
    "separator",
    "sub-content",
    "sub-trigger",
    "trigger"
  ];
  return {
    NAME,
    SUB_NAME,
    RADIO_GROUP_NAME,
    CHECKBOX_ITEM_NAME,
    RADIO_ITEM_NAME,
    GROUP_NAME,
    PARTS
  };
}
function getCtx9() {
  const { NAME } = getMenuData();
  return getContext(NAME);
}
function setCtx10(props) {
  const { NAME, PARTS } = getMenuData();
  const getAttrs2 = createBitAttrs("menu", PARTS);
  const dropdownMenu = {
    ...createDropdownMenu({ ...removeUndefined2(props), forceVisible: true }),
    getAttrs: getAttrs2
  };
  setContext(NAME, dropdownMenu);
  return {
    ...dropdownMenu,
    updateOption: getOptionUpdater(dropdownMenu.options)
  };
}
function setSubMenuCtx(props) {
  const { SUB_NAME } = getMenuData();
  const { builders: { createSubmenu }, getAttrs: getAttrs2 } = getCtx9();
  const sub = { ...createSubmenu(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(SUB_NAME, sub);
  return {
    ...sub,
    updateOption: getOptionUpdater(sub.options)
  };
}
function setRadioGroupCtx(props) {
  const { RADIO_GROUP_NAME } = getMenuData();
  const { builders: { createMenuRadioGroup }, getAttrs: getAttrs2 } = getCtx9();
  const radioGroup = createMenuRadioGroup(props);
  setContext(RADIO_GROUP_NAME, { ...radioGroup, getAttrs: getAttrs2 });
  return {
    ...radioGroup,
    getAttrs: getAttrs2
  };
}
function setRadioItem(value) {
  const { RADIO_ITEM_NAME, RADIO_GROUP_NAME } = getMenuData();
  const dropdownMenu = getContext(RADIO_GROUP_NAME);
  setContext(RADIO_ITEM_NAME, { ...dropdownMenu, value });
  return {
    ...dropdownMenu,
    value
  };
}
function getRadioIndicator() {
  const { RADIO_ITEM_NAME } = getMenuData();
  const radioItem = getContext(RADIO_ITEM_NAME);
  return {
    ...radioItem
  };
}
function getSubTrigger() {
  const { SUB_NAME } = getMenuData();
  const submenu = getContext(SUB_NAME);
  return submenu;
}
function getSubmenuCtx() {
  const { SUB_NAME } = getMenuData();
  return getContext(SUB_NAME);
}
function setCheckboxItem(props) {
  const { CHECKBOX_ITEM_NAME } = getMenuData();
  const { builders: { createCheckboxItem }, getAttrs: getAttrs2 } = getCtx9();
  const checkboxItem = createCheckboxItem(removeUndefined2(props));
  setContext(CHECKBOX_ITEM_NAME, checkboxItem.states.checked);
  return {
    ...checkboxItem,
    updateOption: getOptionUpdater(checkboxItem.options),
    getAttrs: getAttrs2
  };
}
function getCheckboxIndicator() {
  const { CHECKBOX_ITEM_NAME } = getMenuData();
  return getContext(CHECKBOX_ITEM_NAME);
}
function setGroupCtx2() {
  const { GROUP_NAME } = getMenuData();
  const { elements: { group }, getAttrs: getAttrs2 } = getCtx9();
  const id = generateId2();
  setContext(GROUP_NAME, id);
  return { group, id, getAttrs: getAttrs2 };
}
function getGroupLabel2() {
  const { GROUP_NAME } = getMenuData();
  const id = getContext(GROUP_NAME) ?? generateId2();
  const { elements: { groupLabel }, getAttrs: getAttrs2 } = getCtx9();
  return { groupLabel, id, getAttrs: getAttrs2 };
}
function setArrow2(size3 = 8) {
  const menu = getCtx9();
  menu.options.arrowSize.set(size3);
  return menu;
}
function updatePositioning4(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "center"
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx9();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}
function updateSubPositioning(props) {
  const defaultSubPlacement = {
    side: "right",
    align: "start"
  };
  const withDefaults = { ...defaultSubPlacement, ...props };
  const { options: { positioning } } = getSubmenuCtx();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/menu/components/menu-sub.svelte
var get_default_slot_changes47 = (dirty) => ({ subIds: dirty & /*$idValues*/
1 });
var get_default_slot_context47 = (ctx) => ({ subIds: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment50(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[6].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[5],
    get_default_slot_context47
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        33)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[5],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[5]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[5],
              dirty,
              get_default_slot_changes47
            ),
            get_default_slot_context47
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment50.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance50($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_sub", slots, ["default"]);
  let { disabled = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  const { updateOption, ids, states: { subOpen } } = setSubMenuCtx({
    disabled,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.menu, ids.trigger], ([$menuId, $triggerId]) => ({ menu: $menuId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = ["disabled", "open", "onOpenChange"];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Menu_sub> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("disabled" in $$props2) $$invalidate(3, disabled = $$props2.disabled);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(4, onOpenChange = $$props2.onOpenChange);
    if ("$$scope" in $$props2) $$invalidate(5, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setSubMenuCtx,
    disabled,
    open,
    onOpenChange,
    updateOption,
    ids,
    subOpen,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("disabled" in $$props2) $$invalidate(3, disabled = $$props2.disabled);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(4, onOpenChange = $$props2.onOpenChange);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && subOpen.set(open);
    }
    if ($$self.$$.dirty & /*disabled*/
    8) {
      $: updateOption("disabled", disabled);
    }
  };
  return [$idValues, idValues, open, disabled, onOpenChange, $$scope, slots];
}
var Menu_sub = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance50, create_fragment50, safe_not_equal, { disabled: 3, open: 2, onOpenChange: 4 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_sub",
      options,
      id: create_fragment50.name
    });
  }
  get disabled() {
    throw new Error("<Menu_sub>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Menu_sub>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Menu_sub>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Menu_sub>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Menu_sub>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Menu_sub>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_sub_default = Menu_sub;

// node_modules/bits-ui/dist/bits/menu/components/menu-item.svelte
var file47 = "node_modules/bits-ui/dist/bits/menu/components/menu-item.svelte";
var get_default_slot_changes_137 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context_137 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
var get_default_slot_changes48 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context48 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
function create_else_block40(ctx) {
  let previous_tag = (
    /*href*/
    ctx[1] ? "a" : "div"
  );
  let svelte_element_anchor;
  let current;
  validate_dynamic_element(
    /*href*/
    ctx[1] ? "a" : "div"
  );
  validate_void_dynamic_element(
    /*href*/
    ctx[1] ? "a" : "div"
  );
  let svelte_element = (
    /*href*/
    (ctx[1] ? "a" : "div") && create_dynamic_element3(ctx)
  );
  const block = {
    c: function create() {
      if (svelte_element) svelte_element.c();
      svelte_element_anchor = empty();
    },
    l: function claim(nodes) {
      if (svelte_element) svelte_element.l(nodes);
      svelte_element_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (svelte_element) svelte_element.m(target, anchor);
      insert_hydration_dev(target, svelte_element_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*href*/
        ctx2[1] ? "a" : "div"
      ) {
        if (!previous_tag) {
          svelte_element = create_dynamic_element3(ctx2);
          previous_tag = /*href*/
          ctx2[1] ? "a" : "div";
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else if (safe_not_equal(
          previous_tag,
          /*href*/
          ctx2[1] ? "a" : "div"
        )) {
          svelte_element.d(1);
          validate_dynamic_element(
            /*href*/
            ctx2[1] ? "a" : "div"
          );
          validate_void_dynamic_element(
            /*href*/
            ctx2[1] ? "a" : "div"
          );
          svelte_element = create_dynamic_element3(ctx2);
          previous_tag = /*href*/
          ctx2[1] ? "a" : "div";
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else {
          svelte_element.p(ctx2, dirty);
        }
      } else if (previous_tag) {
        svelte_element.d(1);
        svelte_element = null;
        previous_tag = /*href*/
        ctx2[1] ? "a" : "div";
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(svelte_element, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(svelte_element, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element_anchor);
      }
      if (svelte_element) svelte_element.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block40.name,
    type: "else",
    source: "(24:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block45(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context48
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1032)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes48
            ),
            get_default_slot_context48
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block45.name,
    type: "if",
    source: "(22:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_dynamic_element3(ctx) {
  let svelte_element;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_137
  );
  let svelte_element_levels = [
    { href: (
      /*href*/
      ctx[1]
    ) },
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[6]
  ];
  let svelte_element_data = {};
  for (let i = 0; i < svelte_element_levels.length; i += 1) {
    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
  }
  const block = {
    c: function create() {
      svelte_element = element(
        /*href*/
        ctx[1] ? "a" : "div"
      );
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      svelte_element = claim_element(
        nodes,
        /*href*/
        ((ctx[1] ? "a" : "div") || "null").toUpperCase(),
        { href: true }
      );
      var svelte_element_nodes = children(svelte_element);
      if (default_slot) default_slot.l(svelte_element_nodes);
      svelte_element_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_dynamic_element_data(
        /*href*/
        ctx[1] ? "a" : "div"
      )(svelte_element, svelte_element_data);
      add_location(svelte_element, file47, 24, 1, 585);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, svelte_element, anchor);
      if (default_slot) {
        default_slot.m(svelte_element, null);
      }
      ctx[12](svelte_element);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[3].action(svelte_element)),
          listen_dev(
            svelte_element,
            "m-click",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-focusin",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-focusout",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-keydown",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-pointerdown",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-pointerleave",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-pointermove",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1032)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_137
            ),
            get_default_slot_context_137
          );
        }
      }
      set_dynamic_element_data(
        /*href*/
        ctx2[1] ? "a" : "div"
      )(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
        (!current || dirty & /*href*/
        2) && { href: (
          /*href*/
          ctx2[1]
        ) },
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_dynamic_element3.name,
    type: "child_dynamic_element",
    source: '(25:1) <svelte:element   this={href ? \\"a\\" : \\"div\\"}   bind:this={el}   {href}   {...builder} use:builder.action   {...$$restProps}   on:m-click={dispatch}   on:m-focusin={dispatch}   on:m-focusout={dispatch}   on:m-keydown={dispatch}   on:m-pointerdown={dispatch}   on:m-pointerleave={dispatch}   on:m-pointermove={dispatch}  >',
    ctx
  });
  return block;
}
function create_fragment51(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block45, create_else_block40];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment51.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance51($$self, $$props, $$invalidate) {
  let builder;
  let attrs;
  const omit_props_names = ["href", "asChild", "disabled", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $item;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_item", slots, ["default"]);
  let { href = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { disabled = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { item }, getAttrs: getAttrs2 } = getCtx9();
  validate_store(item, "item");
  component_subscribe($$self, item, (value) => $$invalidate(9, $item = value));
  const dispatch = createDispatcher();
  function svelte_element_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("href" in $$new_props) $$invalidate(1, href = $$new_props.href);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    disabledAttrs,
    melt,
    getCtx: getCtx9,
    href,
    asChild,
    disabled,
    el,
    item,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $item
  });
  $$self.$inject_state = ($$new_props) => {
    if ("href" in $$props) $$invalidate(1, href = $$new_props.href);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(8, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$item*/
    512) {
      $: $$invalidate(3, builder = $item);
    }
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: $$invalidate(8, attrs = {
        ...getAttrs2("item"),
        ...disabledAttrs(disabled)
      });
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    264) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    href,
    asChild,
    builder,
    item,
    dispatch,
    $$restProps,
    disabled,
    attrs,
    $item,
    $$scope,
    slots,
    svelte_element_binding
  ];
}
var Menu_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance51, create_fragment51, safe_not_equal, { href: 1, asChild: 2, disabled: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_item",
      options,
      id: create_fragment51.name
    });
  }
  get href() {
    throw new Error("<Menu_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set href(value) {
    throw new Error("<Menu_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Menu_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Menu_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_item_default = Menu_item;

// node_modules/bits-ui/dist/bits/menu/components/menu-group.svelte
var file48 = "node_modules/bits-ui/dist/bits/menu/components/menu-group.svelte";
var get_default_slot_changes_138 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_138 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes49 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context49 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block41(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_138
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file48, 15, 1, 338);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_138
            ),
            get_default_slot_context_138
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block41.name,
    type: "else",
    source: "(15:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block46(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context49
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes49
            ),
            get_default_slot_context49
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block46.name,
    type: "if",
    source: "(13:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment52(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block46, create_else_block41];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment52.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance52($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $group;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_group", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { group, id, getAttrs: getAttrs2 } = setGroupCtx2();
  validate_store(group, "group");
  component_subscribe($$self, group, (value) => $$invalidate(5, $group = value));
  const attrs = getAttrs2("group");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setGroupCtx: setGroupCtx2,
    asChild,
    el,
    group,
    id,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $group
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$group*/
    32) {
      $: $$invalidate(2, builder = $group(id));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, group, $$restProps, $group, $$scope, slots, div_binding];
}
var Menu_group = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance52, create_fragment52, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_group",
      options,
      id: create_fragment52.name
    });
  }
  get asChild() {
    throw new Error("<Menu_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_group_default = Menu_group;

// node_modules/bits-ui/dist/bits/menu/components/menu-label.svelte
var file49 = "node_modules/bits-ui/dist/bits/menu/components/menu-label.svelte";
var get_default_slot_changes_139 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_139 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes50 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context50 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block42(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_139
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file49, 15, 1, 352);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_139
            ),
            get_default_slot_context_139
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block42.name,
    type: "else",
    source: "(15:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block47(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context50
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes50
            ),
            get_default_slot_context50
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block47.name,
    type: "if",
    source: "(13:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment53(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block47, create_else_block42];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment53.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance53($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $groupLabel;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { groupLabel, id, getAttrs: getAttrs2 } = getGroupLabel2();
  validate_store(groupLabel, "groupLabel");
  component_subscribe($$self, groupLabel, (value) => $$invalidate(5, $groupLabel = value));
  const attrs = getAttrs2("label");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getGroupLabel: getGroupLabel2,
    asChild,
    el,
    groupLabel,
    id,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $groupLabel
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$groupLabel*/
    32) {
      $: $$invalidate(2, builder = $groupLabel(id));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    groupLabel,
    $$restProps,
    $groupLabel,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance53, create_fragment53, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_label",
      options,
      id: create_fragment53.name
    });
  }
  get asChild() {
    throw new Error("<Menu_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_label_default = Menu_label;

// node_modules/bits-ui/dist/bits/menu/components/menu-arrow.svelte
var file50 = "node_modules/bits-ui/dist/bits/menu/components/menu-arrow.svelte";
var get_default_slot_changes51 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context51 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block43(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file50, 19, 1, 367);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block43.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block48(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context51
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes51
            ),
            get_default_slot_context51
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block48.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment54(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block48, create_else_block43];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment54.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance54($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["size", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_arrow", slots, ["default"]);
  let { size: size3 = 8 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { arrow: arrow3 }, getAttrs: getAttrs2 } = setArrow2(size3);
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getAttrs2("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setArrow: setArrow2,
    size: size3,
    asChild,
    el,
    arrow: arrow3,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance54, create_fragment54, safe_not_equal, { size: 5, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_arrow",
      options,
      id: create_fragment54.name
    });
  }
  get size() {
    throw new Error("<Menu_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Menu_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_arrow_default = Menu_arrow;

// node_modules/bits-ui/dist/bits/context-menu/components/context-menu-content.svelte
var file51 = "node_modules/bits-ui/dist/bits/context-menu/components/context-menu-content.svelte";
var get_default_slot_changes_55 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_55 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_45 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_45 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_35 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_35 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_25 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_25 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_140 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_140 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes52 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context52 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_56(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[24].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[23],
    get_default_slot_context_55
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file51, 91, 1, 2063);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        8388864)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[23],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[23]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[23],
              dirty,
              get_default_slot_changes_55
            ),
            get_default_slot_context_55
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_56.name,
    type: "if",
    source: "(91:16) ",
    ctx
  });
  return block;
}
function create_if_block_46(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[24].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[23],
    get_default_slot_context_45
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file51, 81, 1, 1870);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[28](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        8388864)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[23],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[23]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[23],
              dirty,
              get_default_slot_changes_45
            ),
            get_default_slot_context_45
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[28](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_46.name,
    type: "if",
    source: "(81:33) ",
    ctx
  });
  return block;
}
function create_if_block_36(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[24].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[23],
    get_default_slot_context_35
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file51, 71, 1, 1663);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[27](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        8388864)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[23],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[23]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[23],
              dirty,
              get_default_slot_changes_35
            ),
            get_default_slot_context_35
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[27](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_36.name,
    type: "if",
    source: "(71:32) ",
    ctx
  });
  return block;
}
function create_if_block_26(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[24].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[23],
    get_default_slot_context_25
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file51, 60, 1, 1415);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[26](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        8388864)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[23],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[23]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[23],
              dirty,
              get_default_slot_changes_25
            ),
            get_default_slot_context_25
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[26](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_26.name,
    type: "if",
    source: "(60:49) ",
    ctx
  });
  return block;
}
function create_if_block_17(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[24].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[23],
    get_default_slot_context_140
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file51, 50, 1, 1188);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[25](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        8388864)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[23],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[23]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[23],
              dirty,
              get_default_slot_changes_140
            ),
            get_default_slot_context_140
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[25](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_17.name,
    type: "if",
    source: "(50:30) ",
    ctx
  });
  return block;
}
function create_if_block49(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[24].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[23],
    get_default_slot_context52
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        8388864)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[23],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[23]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[23],
              dirty,
              get_default_slot_changes52
            ),
            get_default_slot_context52
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block49.name,
    type: "if",
    source: "(48:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment55(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block49,
    create_if_block_17,
    create_if_block_26,
    create_if_block_36,
    create_if_block_46,
    create_if_block_56
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment55.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance55($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $menu;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Context_menu_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { menu }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx8();
  validate_store(menu, "menu");
  component_subscribe($$self, menu, (value) => $$invalidate(22, $menu = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(14, id = $$new_props.id);
    if ("alignOffset" in $$new_props) $$invalidate(15, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(16, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(17, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(18, collisionBoundary = $$new_props.collisionBoundary);
    if ("fitViewport" in $$new_props) $$invalidate(19, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(20, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(21, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(23, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    melt,
    getCtx: getCtx8,
    updatePositioning: updatePositioning3,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    fitViewport,
    strategy,
    overlap,
    el,
    menu,
    open,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $menu,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(14, id = $$new_props.id);
    if ("alignOffset" in $$props) $$invalidate(15, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(16, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(17, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(18, collisionBoundary = $$new_props.collisionBoundary);
    if ("fitViewport" in $$props) $$invalidate(19, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(20, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(21, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    16384) {
      $: if (id) {
        ids.menu.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$menu*/
    4194304) {
      $: $$invalidate(8, builder = $menu);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*alignOffset, collisionPadding, avoidCollisions, collisionBoundary, fitViewport, strategy, overlap*/
    4161536) {
      $: updatePositioning3({
        alignOffset,
        collisionPadding,
        avoidCollisions,
        collisionBoundary,
        fitViewport,
        strategy,
        overlap
      });
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    menu,
    open,
    dispatch,
    $$restProps,
    id,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    fitViewport,
    strategy,
    overlap,
    $menu,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Context_menu_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance55,
      create_fragment55,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 14,
        alignOffset: 15,
        collisionPadding: 16,
        avoidCollisions: 17,
        collisionBoundary: 18,
        fitViewport: 19,
        strategy: 20,
        overlap: 21,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Context_menu_content",
      options,
      id: create_fragment55.name
    });
  }
  get transition() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Context_menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Context_menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var context_menu_content_default = Context_menu_content;

// node_modules/bits-ui/dist/bits/context-menu/components/context-menu-trigger.svelte
var file52 = "node_modules/bits-ui/dist/bits/context-menu/components/context-menu-trigger.svelte";
var get_default_slot_changes_141 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_141 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes53 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context53 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block44(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_141
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file52, 26, 1, 520);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-contextmenu",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointercancel",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerup",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_141
            ),
            get_default_slot_context_141
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block44.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block50(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context53
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes53
            ),
            get_default_slot_context53
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block50.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment56(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block50, create_else_block44];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment56.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance56($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Context_menu_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getAttrs: getAttrs2 } = getCtx8();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(7, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx8,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    128) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    div_binding
  ];
}
var Context_menu_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance56, create_fragment56, safe_not_equal, { asChild: 1, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Context_menu_trigger",
      options,
      id: create_fragment56.name
    });
  }
  get asChild() {
    throw new Error("<Context_menu_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Context_menu_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Context_menu_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Context_menu_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Context_menu_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Context_menu_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var context_menu_trigger_default = Context_menu_trigger;

// node_modules/bits-ui/dist/bits/menu/components/menu-radio-item.svelte
var file53 = "node_modules/bits-ui/dist/bits/menu/components/menu-radio-item.svelte";
var get_default_slot_changes_142 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_142 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes54 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context54 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block45(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_142
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file53, 22, 1, 537);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusin",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_142
            ),
            get_default_slot_context_142
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block45.name,
    type: "else",
    source: "(22:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block51(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context54
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes54
            ),
            get_default_slot_context54
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block51.name,
    type: "if",
    source: "(20:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment57(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block51, create_else_block45];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment57.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance57($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["value", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $radioItem;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_radio_item", slots, ["default"]);
  let { value } = $$props;
  let { disabled = false } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { radioItem }, getAttrs: getAttrs2 } = setRadioItem(value);
  validate_store(radioItem, "radioItem");
  component_subscribe($$self, radioItem, (value2) => $$invalidate(8, $radioItem = value2));
  const attrs = getAttrs2("radio-item");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Menu_radio_item> was created without expected prop 'value'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setRadioItem,
    createDispatcher,
    value,
    disabled,
    asChild,
    el,
    radioItem,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $radioItem
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$radioItem, value, disabled*/
    448) {
      $: $$invalidate(2, builder = $radioItem({ value, disabled }));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    radioItem,
    dispatch,
    $$restProps,
    value,
    disabled,
    $radioItem,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_radio_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance57, create_fragment57, safe_not_equal, { value: 6, disabled: 7, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_radio_item",
      options,
      id: create_fragment57.name
    });
  }
  get value() {
    throw new Error("<Menu_radio_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Menu_radio_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Menu_radio_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Menu_radio_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_radio_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_radio_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_radio_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_radio_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_radio_item_default = Menu_radio_item;

// node_modules/bits-ui/dist/bits/menu/components/menu-separator.svelte
var file54 = "node_modules/bits-ui/dist/bits/menu/components/menu-separator.svelte";
var get_default_slot_changes55 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context55 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block46(ctx) {
  let div;
  let $separator_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*$separator*/
    ctx[3],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file54, 18, 1, 350);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[8](div);
      if (!mounted) {
        dispose = action_destroyer($separator_action_action = /*$separator*/
        ctx[3].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*$separator*/
        8 && /*$separator*/
        ctx2[3],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block46.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block52(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context55
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes55
            ),
            get_default_slot_context55
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block52.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment58(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block52, create_else_block46];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment58.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance58($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $separator;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_separator", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { separator }, getAttrs: getAttrs2 } = getCtx9();
  validate_store(separator, "separator");
  component_subscribe($$self, separator, (value) => $$invalidate(3, $separator = value));
  const attrs = getAttrs2("separator");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx9,
    asChild,
    el,
    separator,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $separator
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$separator*/
    8) {
      $: $$invalidate(2, builder = $separator);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $separator,
    separator,
    $$restProps,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_separator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance58, create_fragment58, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_separator",
      options,
      id: create_fragment58.name
    });
  }
  get asChild() {
    throw new Error("<Menu_separator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_separator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_separator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_separator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_separator_default = Menu_separator;

// node_modules/bits-ui/dist/bits/menu/components/menu-radio-group.svelte
var file55 = "node_modules/bits-ui/dist/bits/menu/components/menu-radio-group.svelte";
var get_default_slot_changes_143 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_143 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes56 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context56 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block47(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_143
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file55, 32, 1, 694);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_143
            ),
            get_default_slot_context_143
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block47.name,
    type: "else",
    source: "(32:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block53(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context56
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes56
            ),
            get_default_slot_context56
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block53.name,
    type: "if",
    source: "(30:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment59(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block53, create_else_block47];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment59.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance59($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["value", "onValueChange", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $radioGroup;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_radio_group", slots, ["default"]);
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { radioGroup }, states: { value: localValue }, getAttrs: getAttrs2 } = setRadioGroupCtx({
    defaultValue: value,
    onValueChange: ({ next: next2 }) => {
      if (next2 != null && next2 !== value) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(5, value = next2);
      }
      return next2;
    }
  });
  validate_store(radioGroup, "radioGroup");
  component_subscribe($$self, radioGroup, (value2) => $$invalidate(7, $radioGroup = value2));
  const attrs = getAttrs2("radio-group");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(6, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setRadioGroupCtx,
    value,
    onValueChange,
    asChild,
    el,
    radioGroup,
    localValue,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $radioGroup
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(6, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    32) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*$radioGroup*/
    128) {
      $: $$invalidate(2, builder = $radioGroup);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    radioGroup,
    $$restProps,
    value,
    onValueChange,
    $radioGroup,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_radio_group = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance59, create_fragment59, safe_not_equal, {
      value: 5,
      onValueChange: 6,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_radio_group",
      options,
      id: create_fragment59.name
    });
  }
  get value() {
    throw new Error("<Menu_radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Menu_radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Menu_radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Menu_radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_radio_group_default = Menu_radio_group;

// node_modules/bits-ui/dist/bits/menu/components/menu-sub-content.svelte
var file56 = "node_modules/bits-ui/dist/bits/menu/components/menu-sub-content.svelte";
var get_default_slot_changes_56 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_56 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_46 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_46 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_36 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_36 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_26 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_26 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_144 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_144 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes57 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context57 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_57(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_56
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file56, 107, 1, 2505);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[33](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes_56
            ),
            get_default_slot_context_56
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[33](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_57.name,
    type: "if",
    source: "(107:19) ",
    ctx
  });
  return block;
}
function create_if_block_47(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_46
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file56, 95, 1, 2252);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_46
            ),
            get_default_slot_context_46
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_47.name,
    type: "if",
    source: "(95:36) ",
    ctx
  });
  return block;
}
function create_if_block_37(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_36
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file56, 83, 1, 1985);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[31](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_36
            ),
            get_default_slot_context_36
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[31](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_37.name,
    type: "if",
    source: "(83:35) ",
    ctx
  });
  return block;
}
function create_if_block_27(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_26
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file56, 70, 1, 1677);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[30](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_26
            ),
            get_default_slot_context_26
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[30](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_27.name,
    type: "if",
    source: "(70:52) ",
    ctx
  });
  return block;
}
function create_if_block_18(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_144
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file56, 58, 1, 1390);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_144
            ),
            get_default_slot_context_144
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_18.name,
    type: "if",
    source: "(58:33) ",
    ctx
  });
  return block;
}
function create_if_block54(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context57
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes57
            ),
            get_default_slot_context57
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block54.name,
    type: "if",
    source: "(56:0) {#if asChild && $subOpen}",
    ctx
  });
  return block;
}
function create_fragment60(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block54,
    create_if_block_18,
    create_if_block_27,
    create_if_block_37,
    create_if_block_47,
    create_if_block_57
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$subOpen*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$subOpen*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$subOpen*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$subOpen*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$subOpen*/
      ctx2[9]
    ) return 4;
    if (
      /*$subOpen*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment60.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance60($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $subMenu;
  let $subOpen;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_sub_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "right" } = $$props;
  let { align = "start" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = false } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { subMenu }, states: { subOpen }, ids, getAttrs: getAttrs2 } = getSubmenuCtx();
  validate_store(subMenu, "subMenu");
  component_subscribe($$self, subMenu, (value) => $$invalidate(26, $subMenu = value));
  validate_store(subOpen, "subOpen");
  component_subscribe($$self, subOpen, (value) => $$invalidate(9, $subOpen = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("sub-content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(27, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    createDispatcher,
    getSubmenuCtx,
    updateSubPositioning,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    subMenu,
    subOpen,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $subMenu,
    $subOpen
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    16384) {
      $: if (id) {
        ids.menu.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$subMenu*/
    67108864) {
      $: $$invalidate(8, builder = $subMenu);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    67076096) {
      $: updateSubPositioning({
        side,
        align,
        sideOffset,
        alignOffset,
        collisionPadding,
        avoidCollisions,
        collisionBoundary,
        sameWidth,
        fitViewport,
        strategy,
        overlap
      });
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $subOpen,
    subMenu,
    subOpen,
    dispatch,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $subMenu,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Menu_sub_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance60,
      create_fragment60,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 14,
        side: 15,
        align: 16,
        sideOffset: 17,
        alignOffset: 18,
        collisionPadding: 19,
        avoidCollisions: 20,
        collisionBoundary: 21,
        sameWidth: 22,
        fitViewport: 23,
        strategy: 24,
        overlap: 25,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_sub_content",
      options,
      id: create_fragment60.name
    });
  }
  get transition() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_sub_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_sub_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_sub_content_default = Menu_sub_content;

// node_modules/bits-ui/dist/bits/menu/components/menu-sub-trigger.svelte
var file57 = "node_modules/bits-ui/dist/bits/menu/components/menu-sub-trigger.svelte";
var get_default_slot_changes_145 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_145 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes58 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context58 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block48(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context_145
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file57, 34, 1, 751);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[14](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusin",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes_145
            ),
            get_default_slot_context_145
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[14](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block48.name,
    type: "else",
    source: "(34:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block55(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context58
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes58
            ),
            get_default_slot_context58
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block55.name,
    type: "if",
    source: "(32:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment61(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block55, create_else_block48];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment61.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance61($$self, $$props, $$invalidate) {
  let builder;
  let attrs;
  const omit_props_names = ["disabled", "asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $disabledStore;
  let $subTrigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_sub_trigger", slots, ["default"]);
  let { disabled = false } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { subTrigger }, ids, getAttrs: getAttrs2, options } = getSubTrigger();
  validate_store(subTrigger, "subTrigger");
  component_subscribe($$self, subTrigger, (value) => $$invalidate(11, $subTrigger = value));
  const { disabled: disabledStore } = options;
  validate_store(disabledStore, "disabledStore");
  component_subscribe($$self, disabledStore, (value) => $$invalidate(10, $disabledStore = value));
  const dispatch = createDispatcher();
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(8, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(12, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    disabledAttrs,
    getSubTrigger,
    createDispatcher,
    disabled,
    asChild,
    id,
    el,
    subTrigger,
    ids,
    getAttrs: getAttrs2,
    options,
    disabledStore,
    dispatch,
    attrs,
    builder,
    $disabledStore,
    $subTrigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(8, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(9, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    256) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$subTrigger*/
    2048) {
      $: $$invalidate(2, builder = $subTrigger);
    }
    if ($$self.$$.dirty & /*disabled, $disabledStore*/
    1152) {
      $: $$invalidate(9, attrs = {
        ...getAttrs2("sub-trigger"),
        ...disabledAttrs(disabled || $disabledStore)
      });
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    516) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    subTrigger,
    disabledStore,
    dispatch,
    $$restProps,
    disabled,
    id,
    attrs,
    $disabledStore,
    $subTrigger,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_sub_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance61, create_fragment61, safe_not_equal, { disabled: 7, asChild: 1, id: 8, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_sub_trigger",
      options,
      id: create_fragment61.name
    });
  }
  get disabled() {
    throw new Error("<Menu_sub_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Menu_sub_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_sub_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_sub_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Menu_sub_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Menu_sub_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_sub_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_sub_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_sub_trigger_default = Menu_sub_trigger;

// node_modules/bits-ui/dist/bits/menu/components/menu-checkbox-item.svelte
var file58 = "node_modules/bits-ui/dist/bits/menu/components/menu-checkbox-item.svelte";
var get_default_slot_changes_146 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_146 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes59 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context59 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block49(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_146
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file58, 39, 1, 908);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[12](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusin",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_146
            ),
            get_default_slot_context_146
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block49.name,
    type: "else",
    source: "(39:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block56(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context59
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes59
            ),
            get_default_slot_context59
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block56.name,
    type: "if",
    source: "(37:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment62(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block56, create_else_block49];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment62.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance62($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["checked", "onCheckedChange", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $checkboxItem;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_checkbox_item", slots, ["default"]);
  let { checked = void 0 } = $$props;
  let { onCheckedChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { checkboxItem }, states: { checked: localChecked }, updateOption, getAttrs: getAttrs2 } = setCheckboxItem({
    disabled,
    defaultChecked: checked,
    onCheckedChange: ({ next: next2 }) => {
      if (checked !== next2) {
        onCheckedChange == null ? void 0 : onCheckedChange(next2);
        $$invalidate(6, checked = next2);
      }
      return next2;
    }
  });
  validate_store(checkboxItem, "checkboxItem");
  component_subscribe($$self, checkboxItem, (value) => $$invalidate(9, $checkboxItem = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("checkbox-item");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("checked" in $$new_props) $$invalidate(6, checked = $$new_props.checked);
    if ("onCheckedChange" in $$new_props) $$invalidate(7, onCheckedChange = $$new_props.onCheckedChange);
    if ("disabled" in $$new_props) $$invalidate(8, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCheckboxItem,
    createDispatcher,
    checked,
    onCheckedChange,
    disabled,
    asChild,
    el,
    checkboxItem,
    localChecked,
    updateOption,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $checkboxItem
  });
  $$self.$inject_state = ($$new_props) => {
    if ("checked" in $$props) $$invalidate(6, checked = $$new_props.checked);
    if ("onCheckedChange" in $$props) $$invalidate(7, onCheckedChange = $$new_props.onCheckedChange);
    if ("disabled" in $$props) $$invalidate(8, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*checked*/
    64) {
      $: checked !== void 0 && localChecked.set(checked);
    }
    if ($$self.$$.dirty & /*disabled*/
    256) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*$checkboxItem*/
    512) {
      $: $$invalidate(2, builder = $checkboxItem);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    checkboxItem,
    dispatch,
    $$restProps,
    checked,
    onCheckedChange,
    disabled,
    $checkboxItem,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_checkbox_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance62, create_fragment62, safe_not_equal, {
      checked: 6,
      onCheckedChange: 7,
      disabled: 8,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_checkbox_item",
      options,
      id: create_fragment62.name
    });
  }
  get checked() {
    throw new Error("<Menu_checkbox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set checked(value) {
    throw new Error("<Menu_checkbox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onCheckedChange() {
    throw new Error("<Menu_checkbox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onCheckedChange(value) {
    throw new Error("<Menu_checkbox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Menu_checkbox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Menu_checkbox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_checkbox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_checkbox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_checkbox_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_checkbox_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_checkbox_item_default = Menu_checkbox_item;

// node_modules/bits-ui/dist/bits/menu/components/menu-radio-indicator.svelte
var file59 = "node_modules/bits-ui/dist/bits/menu/components/menu-radio-indicator.svelte";
var get_default_slot_changes_147 = (dirty) => ({ checked: dirty & /*checked*/
4 });
var get_default_slot_context_147 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[4]
  ),
  checked: (
    /*checked*/
    ctx[2]
  )
});
var get_default_slot_changes60 = (dirty) => ({ checked: dirty & /*checked*/
4 });
var get_default_slot_context60 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[4]
  ),
  checked: (
    /*checked*/
    ctx[2]
  )
});
function create_else_block50(ctx) {
  let div;
  let current;
  let if_block = (
    /*checked*/
    ctx[2] && create_if_block_19(ctx)
  );
  let div_levels = [
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (if_block) if_block.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (if_block) if_block.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file59, 16, 1, 325);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (if_block) if_block.m(div, null);
      ctx[9](div);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*checked*/
        ctx2[2]
      ) {
        if (if_block) {
          if_block.p(ctx2, dirty);
          if (dirty & /*checked*/
          4) {
            transition_in(if_block, 1);
          }
        } else {
          if_block = create_if_block_19(ctx2);
          if_block.c();
          transition_in(if_block, 1);
          if_block.m(div, null);
        }
      } else if (if_block) {
        group_outros();
        transition_out(if_block, 1, 1, () => {
          if_block = null;
        });
        check_outros();
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        /*attrs*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (if_block) if_block.d();
      ctx[9](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block50.name,
    type: "else",
    source: "(16:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block57(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context60
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, checked*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes60
            ),
            get_default_slot_context60
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block57.name,
    type: "if",
    source: "(14:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_if_block_19(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_147
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, checked*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_147
            ),
            get_default_slot_context_147
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_19.name,
    type: "if",
    source: "(18:2) {#if checked}",
    ctx
  });
  return block;
}
function create_fragment63(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block57, create_else_block50];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment63.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance63($$self, $$props, $$invalidate) {
  let checked;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isChecked;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_radio_indicator", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { helpers: { isChecked }, value, getAttrs: getAttrs2 } = getRadioIndicator();
  validate_store(isChecked, "isChecked");
  component_subscribe($$self, isChecked, (value2) => $$invalidate(6, $isChecked = value2));
  const attrs = getAttrs2("radio-indicator");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getRadioIndicator,
    asChild,
    el,
    isChecked,
    value,
    getAttrs: getAttrs2,
    attrs,
    checked,
    $isChecked
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("checked" in $$props) $$invalidate(2, checked = $$new_props.checked);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$isChecked*/
    64) {
      $: $$invalidate(2, checked = $isChecked(value));
    }
  };
  return [
    el,
    asChild,
    checked,
    isChecked,
    attrs,
    $$restProps,
    $isChecked,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_radio_indicator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance63, create_fragment63, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_radio_indicator",
      options,
      id: create_fragment63.name
    });
  }
  get asChild() {
    throw new Error("<Menu_radio_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_radio_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_radio_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_radio_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_radio_indicator_default = Menu_radio_indicator;

// node_modules/bits-ui/dist/bits/menu/components/menu-checkbox-indicator.svelte
var file60 = "node_modules/bits-ui/dist/bits/menu/components/menu-checkbox-indicator.svelte";
var get_default_slot_changes_148 = (dirty) => ({ checked: dirty & /*$checked*/
4 });
var get_default_slot_context_148 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[4]
  ),
  checked: (
    /*$checked*/
    ctx[2]
  )
});
var get_default_slot_changes61 = (dirty) => ({ checked: dirty & /*$checked*/
4 });
var get_default_slot_context61 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[4]
  ),
  checked: (
    /*$checked*/
    ctx[2]
  )
});
function create_else_block51(ctx) {
  let div;
  let current;
  let if_block = (
    /*$checked*/
    ctx[2] && create_if_block_110(ctx)
  );
  let div_levels = [
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (if_block) if_block.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (if_block) if_block.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file60, 11, 1, 306);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (if_block) if_block.m(div, null);
      ctx[8](div);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*$checked*/
        ctx2[2]
      ) {
        if (if_block) {
          if_block.p(ctx2, dirty);
          if (dirty & /*$checked*/
          4) {
            transition_in(if_block, 1);
          }
        } else {
          if_block = create_if_block_110(ctx2);
          if_block.c();
          transition_in(if_block, 1);
          if_block.m(div, null);
        }
      } else if (if_block) {
        group_outros();
        transition_out(if_block, 1, 1, () => {
          if_block = null;
        });
        check_outros();
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        /*attrs*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (if_block) if_block.d();
      ctx[8](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block51.name,
    type: "else",
    source: "(11:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block58(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context61
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $checked*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes61
            ),
            get_default_slot_context61
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block58.name,
    type: "if",
    source: "(9:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_if_block_110(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_148
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $checked*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_148
            ),
            get_default_slot_context_148
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_110.name,
    type: "if",
    source: "(13:2) {#if $checked}",
    ctx
  });
  return block;
}
function create_fragment64(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block58, create_else_block51];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment64.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance64($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $checked;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_checkbox_indicator", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const checked = getCheckboxIndicator();
  validate_store(checked, "checked");
  component_subscribe($$self, checked, (value) => $$invalidate(2, $checked = value));
  const { getAttrs: getAttrs2 } = getCtx9();
  const attrs = getAttrs2("checkbox-indicator");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCheckboxIndicator,
    getCtx: getCtx9,
    asChild,
    el,
    checked,
    getAttrs: getAttrs2,
    attrs,
    $checked
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [
    el,
    asChild,
    $checked,
    checked,
    attrs,
    $$restProps,
    $$scope,
    slots,
    div_binding
  ];
}
var Menu_checkbox_indicator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance64, create_fragment64, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_checkbox_indicator",
      options,
      id: create_fragment64.name
    });
  }
  get asChild() {
    throw new Error("<Menu_checkbox_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_checkbox_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_checkbox_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_checkbox_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_checkbox_indicator_default = Menu_checkbox_indicator;

// node_modules/bits-ui/dist/bits/date-field/index.js
var date_field_exports = {};
__export(date_field_exports, {
  Input: () => date_field_input_default,
  Label: () => date_field_label_default,
  Root: () => date_field_default,
  Segment: () => date_field_segment_default
});

// node_modules/bits-ui/dist/bits/date-field/ctx.js
function getDateFieldData() {
  const NAME = "date-field";
  const PARTS = ["label", "input", "segment"];
  return {
    NAME,
    PARTS
  };
}
function setCtx11(props) {
  const { NAME, PARTS } = getDateFieldData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const dateField = { ...createDateField(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, dateField);
  return {
    ...dateField,
    updateOption: getOptionUpdater(dateField.options)
  };
}
function getCtx10() {
  const { NAME } = getDateFieldData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/date-field/components/date-field.svelte
var get_default_slot_changes62 = (dirty) => ({
  isInvalid: dirty & /*$localIsInvalid*/
  1,
  ids: dirty & /*$idValues*/
  2
});
var get_default_slot_context62 = (ctx) => ({
  isInvalid: (
    /*$localIsInvalid*/
    ctx[0]
  ),
  ids: (
    /*$idValues*/
    ctx[1]
  )
});
function create_fragment65(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[21].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[20],
    get_default_slot_context62
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $localIsInvalid, $idValues*/
        1048579)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[20],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[20]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[20],
              dirty,
              get_default_slot_changes62
            ),
            get_default_slot_context62
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment65.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance65($$self, $$props, $$invalidate) {
  let $localIsInvalid;
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_field", slots, ["default"]);
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { granularity = void 0 } = $$props;
  let { hideTimeZone = void 0 } = $$props;
  let { hourCycle = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  let { validationId = void 0 } = $$props;
  let { descriptionId = void 0 } = $$props;
  let { readonlySegments = void 0 } = $$props;
  const { states: { value: localValue, placeholder: localPlaceholder, isInvalid: localIsInvalid }, updateOption, ids } = setCtx11({
    defaultValue: value,
    defaultPlaceholder: placeholder,
    disabled,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    readonlySegments,
    isDateUnavailable,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(4, value = next2);
      }
      return next2;
    },
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(5, placeholder = next2);
      }
      return next2;
    }
  });
  validate_store(localIsInvalid, "localIsInvalid");
  component_subscribe($$self, localIsInvalid, (value2) => $$invalidate(0, $localIsInvalid = value2));
  const idValues = derived(
    [
      ids.day,
      ids.description,
      ids.dayPeriod,
      ids.field,
      ids.hour,
      ids.minute,
      ids.month,
      ids.second,
      ids.year,
      ids.validation,
      ids.label,
      ids.timeZoneName
    ],
    ([
      $dayId,
      $descriptionId,
      $dayPeriodId,
      $fieldId,
      $hourId,
      $minuteId,
      $monthId,
      $secondId,
      $yearId,
      $validationId,
      $labelId,
      $timeZoneNameId
    ]) => ({
      day: $dayId,
      description: $descriptionId,
      dayPeriod: $dayPeriodId,
      field: $fieldId,
      hour: $hourId,
      minute: $minuteId,
      month: $monthId,
      second: $secondId,
      year: $yearId,
      validation: $validationId,
      label: $labelId,
      timeZoneName: $timeZoneNameId
    })
  );
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value2) => $$invalidate(1, $idValues = value2));
  const writable_props = [
    "value",
    "onValueChange",
    "placeholder",
    "onPlaceholderChange",
    "disabled",
    "isDateUnavailable",
    "granularity",
    "hideTimeZone",
    "hourCycle",
    "locale",
    "maxValue",
    "minValue",
    "readonly",
    "validationId",
    "descriptionId",
    "readonlySegments"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Date_field> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("value" in $$props2) $$invalidate(4, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(6, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(5, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(7, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(9, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(10, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(11, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(12, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(13, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(14, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(15, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(16, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(17, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(18, descriptionId = $$props2.descriptionId);
    if ("readonlySegments" in $$props2) $$invalidate(19, readonlySegments = $$props2.readonlySegments);
    if ("$$scope" in $$props2) $$invalidate(20, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx11,
    value,
    onValueChange,
    placeholder,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    validationId,
    descriptionId,
    readonlySegments,
    localValue,
    localPlaceholder,
    localIsInvalid,
    updateOption,
    ids,
    idValues,
    $localIsInvalid,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("value" in $$props2) $$invalidate(4, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(6, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(5, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(7, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(9, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(10, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(11, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(12, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(13, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(14, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(15, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(16, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(17, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(18, descriptionId = $$props2.descriptionId);
    if ("readonlySegments" in $$props2) $$invalidate(19, readonlySegments = $$props2.readonlySegments);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*validationId*/
    131072) {
      $: if (validationId) {
        ids.validation.set(validationId);
      }
    }
    if ($$self.$$.dirty & /*descriptionId*/
    262144) {
      $: if (descriptionId) {
        ids.description.set(descriptionId);
      }
    }
    if ($$self.$$.dirty & /*value*/
    16) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*placeholder*/
    32) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty & /*disabled*/
    256) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*isDateUnavailable*/
    512) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty & /*granularity*/
    1024) {
      $: updateOption("granularity", granularity);
    }
    if ($$self.$$.dirty & /*hideTimeZone*/
    2048) {
      $: updateOption("hideTimeZone", hideTimeZone);
    }
    if ($$self.$$.dirty & /*hourCycle*/
    4096) {
      $: updateOption("hourCycle", hourCycle);
    }
    if ($$self.$$.dirty & /*locale*/
    8192) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty & /*maxValue*/
    16384) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty & /*minValue*/
    32768) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty & /*readonly*/
    65536) {
      $: updateOption("readonly", readonly2);
    }
    if ($$self.$$.dirty & /*readonlySegments*/
    524288) {
      $: updateOption("readonlySegments", readonlySegments);
    }
  };
  return [
    $localIsInvalid,
    $idValues,
    localIsInvalid,
    idValues,
    value,
    placeholder,
    onValueChange,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly2,
    validationId,
    descriptionId,
    readonlySegments,
    $$scope,
    slots
  ];
}
var Date_field = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance65, create_fragment65, safe_not_equal, {
      value: 4,
      onValueChange: 6,
      placeholder: 5,
      onPlaceholderChange: 7,
      disabled: 8,
      isDateUnavailable: 9,
      granularity: 10,
      hideTimeZone: 11,
      hourCycle: 12,
      locale: 13,
      maxValue: 14,
      minValue: 15,
      readonly: 16,
      validationId: 17,
      descriptionId: 18,
      readonlySegments: 19
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_field",
      options,
      id: create_fragment65.name
    });
  }
  get value() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get placeholder() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get granularity() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set granularity(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hideTimeZone() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hideTimeZone(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hourCycle() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hourCycle(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get validationId() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set validationId(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get descriptionId() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set descriptionId(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonlySegments() {
    throw new Error("<Date_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonlySegments(value) {
    throw new Error("<Date_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_field_default = Date_field;

// node_modules/bits-ui/dist/bits/date-field/components/date-field-input.svelte
var file61 = "node_modules/bits-ui/dist/bits/date-field/components/date-field-input.svelte";
var get_default_slot_changes_149 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  segments: dirty & /*$segmentContents*/
  8
});
var get_default_slot_context_149 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  segments: (
    /*$segmentContents*/
    ctx[3]
  )
});
var get_default_slot_changes63 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  segments: dirty & /*$segmentContents*/
  8
});
var get_default_slot_context63 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  segments: (
    /*$segmentContents*/
    ctx[3]
  )
});
function create_else_block52(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_149
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file61, 25, 1, 470);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $segmentContents*/
        524)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_149
            ),
            get_default_slot_context_149
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block52.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block59(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context63
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $segmentContents*/
        524)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes63
            ),
            get_default_slot_context63
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block59.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment66(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block59, create_else_block52];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment66.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance66($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $field;
  let $segmentContents;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_field_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { field }, states: { segmentContents }, ids, getAttrs: getAttrs2 } = getCtx10();
  validate_store(field, "field");
  component_subscribe($$self, field, (value) => $$invalidate(8, $field = value));
  validate_store(segmentContents, "segmentContents");
  component_subscribe($$self, segmentContents, (value) => $$invalidate(3, $segmentContents = value));
  const attrs = getAttrs2("input");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx10,
    asChild,
    id,
    el,
    field,
    segmentContents,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $field,
    $segmentContents
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    128) {
      $: if (id) {
        ids.field.set(id);
      }
    }
    if ($$self.$$.dirty & /*$field*/
    256) {
      $: $$invalidate(2, builder = $field);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $segmentContents,
    field,
    segmentContents,
    $$restProps,
    id,
    $field,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_field_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance66, create_fragment66, safe_not_equal, { asChild: 1, id: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_field_input",
      options,
      id: create_fragment66.name
    });
  }
  get asChild() {
    throw new Error("<Date_field_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_field_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_field_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_field_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_field_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_field_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_field_input_default = Date_field_input;

// node_modules/bits-ui/dist/bits/date-field/components/date-field-label.svelte
var file62 = "node_modules/bits-ui/dist/bits/date-field/components/date-field-label.svelte";
var get_default_slot_changes_150 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_150 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes64 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context64 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block53(ctx) {
  let span;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_150
  );
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      var span_nodes = children(span);
      if (default_slot) default_slot.l(span_nodes);
      span_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file62, 23, 1, 402);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      if (default_slot) {
        default_slot.m(span, null);
      }
      ctx[9](span);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_150
            ),
            get_default_slot_context_150
          );
        }
      }
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block53.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block60(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context64
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes64
            ),
            get_default_slot_context64
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block60.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment67(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block60, create_else_block53];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment67.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance67($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $label;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_field_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { label }, ids, getAttrs: getAttrs2 } = getCtx10();
  validate_store(label, "label");
  component_subscribe($$self, label, (value) => $$invalidate(6, $label = value));
  if (id) {
    ids.label.set(id);
  }
  const attrs = getAttrs2("label");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx10,
    asChild,
    id,
    el,
    label,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $label
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$label*/
    64) {
      $: $$invalidate(2, builder = $label);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    label,
    $$restProps,
    id,
    $label,
    $$scope,
    slots,
    span_binding
  ];
}
var Date_field_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance67, create_fragment67, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_field_label",
      options,
      id: create_fragment67.name
    });
  }
  get asChild() {
    throw new Error("<Date_field_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_field_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_field_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_field_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_field_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_field_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_field_label_default = Date_field_label;

// node_modules/bits-ui/dist/bits/date-field/components/date-field-segment.svelte
var file63 = "node_modules/bits-ui/dist/bits/date-field/components/date-field-segment.svelte";
var get_default_slot_changes_151 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_151 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes65 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context65 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block54(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_151
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file63, 27, 1, 563);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_151
            ),
            get_default_slot_context_151
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block54.name,
    type: "else",
    source: "(27:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block61(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context65
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes65
            ),
            get_default_slot_context65
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block61.name,
    type: "if",
    source: "(25:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment68(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block61, create_else_block54];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment68.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance68($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "part", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $segment;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_field_segment", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { part } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { segment }, ids, getAttrs: getAttrs2 } = getCtx10();
  validate_store(segment, "segment");
  component_subscribe($$self, segment, (value) => $$invalidate(8, $segment = value));
  const attrs = getAttrs2("segment");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (part === void 0 && !("part" in $$props || $$self.$$.bound[$$self.$$.props["part"]])) {
      console.warn("<Date_field_segment> was created without expected prop 'part'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("part" in $$new_props) $$invalidate(7, part = $$new_props.part);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx10,
    createDispatcher,
    asChild,
    id,
    part,
    el,
    segment,
    ids,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $segment
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("part" in $$props) $$invalidate(7, part = $$new_props.part);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id, part*/
    192) {
      $: if (id && part !== "literal") {
        ids[part].set(id);
      }
    }
    if ($$self.$$.dirty & /*$segment, part*/
    384) {
      $: $$invalidate(2, builder = $segment(part));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    segment,
    dispatch,
    $$restProps,
    id,
    part,
    $segment,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_field_segment = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance68, create_fragment68, safe_not_equal, { asChild: 1, id: 6, part: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_field_segment",
      options,
      id: create_fragment68.name
    });
  }
  get asChild() {
    throw new Error("<Date_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get part() {
    throw new Error("<Date_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set part(value) {
    throw new Error("<Date_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_field_segment_default = Date_field_segment;

// node_modules/bits-ui/dist/bits/date-picker/index.js
var date_picker_exports = {};
__export(date_picker_exports, {
  Arrow: () => date_picker_arrow_default,
  Calendar: () => date_picker_calendar_default,
  Cell: () => date_picker_cell_default,
  Close: () => date_picker_close_default,
  Content: () => date_picker_content_default,
  Day: () => date_picker_day_default,
  Field: () => date_picker_field_default,
  Grid: () => date_picker_grid_default,
  GridBody: () => date_picker_grid_body_default,
  GridHead: () => date_picker_grid_head_default,
  GridRow: () => date_picker_grid_row_default,
  HeadCell: () => date_picker_head_cell_default,
  Header: () => date_picker_header_default,
  Heading: () => date_picker_heading_default,
  Input: () => date_picker_input_default,
  Label: () => date_picker_label_default,
  NextButton: () => date_picker_next_button_default,
  PrevButton: () => date_picker_prev_button_default,
  Root: () => date_picker_default,
  Segment: () => date_picker_segment_default,
  Trigger: () => date_picker_trigger_default
});

// node_modules/bits-ui/dist/bits/popover/ctx.js
function getPopoverData() {
  const NAME = "popover";
  const PARTS = ["arrow", "close", "content", "trigger"];
  return {
    NAME,
    PARTS
  };
}
function setCtx12(props) {
  const { NAME, PARTS } = getPopoverData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const popover = {
    ...createPopover({
      positioning: {
        placement: "bottom",
        gutter: 0
      },
      ...removeUndefined2(props),
      forceVisible: true
    }),
    getAttrs: getAttrs2
  };
  setContext(NAME, popover);
  return {
    ...popover,
    updateOption: getOptionUpdater(popover.options)
  };
}
function getCtx11() {
  const { NAME } = getPopoverData();
  return getContext(NAME);
}
function setArrow3(size3 = 8) {
  const popover = getCtx11();
  popover.options.arrowSize.set(size3);
  return popover;
}
function updatePositioning5(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "center"
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx11();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/date-picker/ctx.js
function getDatePickerData() {
  const NAME = "date-picker";
  return {
    NAME
  };
}
function setCtx13(props) {
  const { NAME } = getDatePickerData();
  const { NAME: CALENDAR_NAME, PARTS: CALENDAR_PARTS } = getCalendarData();
  const getCalendarAttrs = createBitAttrs(CALENDAR_NAME, CALENDAR_PARTS);
  const { NAME: FIELD_NAME, PARTS: FIELD_PARTS } = getDateFieldData();
  const getFieldAttrs = createBitAttrs(FIELD_NAME, FIELD_PARTS);
  const { NAME: POPOVER_NAME, PARTS: POPOVER_PARTS } = getPopoverData();
  const getPopoverAttrs = createBitAttrs(POPOVER_NAME, POPOVER_PARTS);
  const datePicker = {
    ...createDatePicker({ ...removeUndefined2(props), forceVisible: true }),
    getCalendarAttrs,
    getFieldAttrs,
    getPopoverAttrs
  };
  const updateOption = getOptionUpdater(datePicker.options);
  setContext(NAME, { ...datePicker, updateOption });
  return {
    ...datePicker,
    updateOption
  };
}
function getCtx12() {
  const { NAME } = getDatePickerData();
  return getContext(NAME);
}
function updatePositioning6(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "center"
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx12();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-arrow.svelte
var file64 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-arrow.svelte";
var get_default_slot_changes66 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context66 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block55(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file64, 22, 1, 427);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block55.name,
    type: "else",
    source: "(22:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block62(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context66
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes66
            ),
            get_default_slot_context66
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block62.name,
    type: "if",
    source: "(20:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment69(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block62, create_else_block55];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment69.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance69($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "size"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_arrow", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { size: size3 = 8 } = $$props;
  const { elements: { arrow: arrow3 }, updateOption, getPopoverAttrs } = getCtx12();
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getPopoverAttrs("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx12,
    melt,
    asChild,
    el,
    size: size3,
    arrow: arrow3,
    updateOption,
    getPopoverAttrs,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*size*/
    32) {
      $: updateOption("arrowSize", size3);
    }
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_picker_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance69, create_fragment69, safe_not_equal, { asChild: 1, el: 0, size: 5 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_arrow",
      options,
      id: create_fragment69.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get size() {
    throw new Error("<Date_picker_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Date_picker_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_arrow_default = Date_picker_arrow;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-calendar.svelte
var file65 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-calendar.svelte";
var get_default_slot_changes_152 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  months: dirty & /*months*/
  8,
  weekdays: dirty & /*$weekdays*/
  16
});
var get_default_slot_context_152 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  months: (
    /*months*/
    ctx[3]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[4]
  )
});
var get_default_slot_changes67 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  months: dirty & /*months*/
  8,
  weekdays: dirty & /*$weekdays*/
  16
});
var get_default_slot_context67 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  months: (
    /*months*/
    ctx[3]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[4]
  )
});
function create_else_block56(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[14].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[13],
    get_default_slot_context_152
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[9]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file65, 30, 1, 675);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[15](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[8],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, months, $weekdays*/
        8220)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[13],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[13]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[13],
              dirty,
              get_default_slot_changes_152
            ),
            get_default_slot_context_152
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        512 && /*$$restProps*/
        ctx2[9]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[15](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block56.name,
    type: "else",
    source: "(30:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block63(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[14].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[13],
    get_default_slot_context67
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, months, $weekdays*/
        8220)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[13],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[13]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[13],
              dirty,
              get_default_slot_changes67
            ),
            get_default_slot_context67
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block63.name,
    type: "if",
    source: "(28:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment70(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block63, create_else_block56];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment70.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance70($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $localMonths;
  let $calendar;
  let $weekdays;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_calendar", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { calendar }, states: { months: localMonths, weekdays }, ids, getCalendarAttrs } = getCtx12();
  validate_store(calendar, "calendar");
  component_subscribe($$self, calendar, (value) => $$invalidate(12, $calendar = value));
  validate_store(localMonths, "localMonths");
  component_subscribe($$self, localMonths, (value) => $$invalidate(11, $localMonths = value));
  validate_store(weekdays, "weekdays");
  component_subscribe($$self, weekdays, (value) => $$invalidate(4, $weekdays = value));
  const attrs = getCalendarAttrs("root");
  const dispatch = createDispatcher();
  let months = $localMonths;
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(9, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(10, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(13, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    createDispatcher,
    asChild,
    id,
    el,
    calendar,
    localMonths,
    weekdays,
    ids,
    getCalendarAttrs,
    attrs,
    dispatch,
    months,
    builder,
    $localMonths,
    $calendar,
    $weekdays
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(10, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("months" in $$props) $$invalidate(3, months = $$new_props.months);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    1024) {
      $: if (id) {
        ids.calendar.calendar.set(id);
      }
    }
    if ($$self.$$.dirty & /*$calendar*/
    4096) {
      $: $$invalidate(2, builder = $calendar);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$localMonths*/
    2048) {
      $: $$invalidate(3, months = $localMonths);
    }
  };
  return [
    el,
    asChild,
    builder,
    months,
    $weekdays,
    calendar,
    localMonths,
    weekdays,
    dispatch,
    $$restProps,
    id,
    $localMonths,
    $calendar,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_picker_calendar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance70, create_fragment70, safe_not_equal, { asChild: 1, id: 10, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_calendar",
      options,
      id: create_fragment70.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_picker_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_picker_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_calendar_default = Date_picker_calendar;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-close.svelte
var file66 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-close.svelte";
var get_default_slot_changes_153 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_153 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes68 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context68 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block57(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_153
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file66, 20, 1, 453);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_153
            ),
            get_default_slot_context_153
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block57.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block64(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context68
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes68
            ),
            get_default_slot_context68
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block64.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment71(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block64, create_else_block57];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment71.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance71($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $close;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_close", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { close }, getPopoverAttrs } = getCtx12();
  validate_store(close, "close");
  component_subscribe($$self, close, (value) => $$invalidate(6, $close = value));
  const dispatch = createDispatcher();
  const attrs = getPopoverAttrs("close");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    createDispatcher,
    asChild,
    el,
    close,
    getPopoverAttrs,
    dispatch,
    attrs,
    builder,
    $close
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$close*/
    64) {
      $: $$invalidate(2, builder = $close);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    close,
    dispatch,
    $$restProps,
    $close,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_picker_close = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance71, create_fragment71, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_close",
      options,
      id: create_fragment71.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_close_default = Date_picker_close;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-content.svelte
var file67 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-content.svelte";
var get_default_slot_changes_57 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_57 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_47 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_47 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_37 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_37 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_27 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_27 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_154 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_154 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes69 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context69 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_58(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_57
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file67, 78, 1, 2025);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[26],
              dirty,
              get_default_slot_changes_57
            ),
            get_default_slot_context_57
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_58.name,
    type: "if",
    source: "(78:16) ",
    ctx
  });
  return block;
}
function create_if_block_48(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_47
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file67, 74, 1, 1868);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[31](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_47
            ),
            get_default_slot_context_47
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[31](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_48.name,
    type: "if",
    source: "(74:33) ",
    ctx
  });
  return block;
}
function create_if_block_38(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_37
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file67, 70, 1, 1697);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[30](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_37
            ),
            get_default_slot_context_37
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[30](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_38.name,
    type: "if",
    source: "(70:32) ",
    ctx
  });
  return block;
}
function create_if_block_28(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_27
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file67, 60, 1, 1475);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_27
            ),
            get_default_slot_context_27
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_28.name,
    type: "if",
    source: "(60:49) ",
    ctx
  });
  return block;
}
function create_if_block_111(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_154
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file67, 56, 1, 1284);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[28](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_154
            ),
            get_default_slot_context_154
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[28](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_111.name,
    type: "if",
    source: "(56:30) ",
    ctx
  });
  return block;
}
function create_if_block65(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context69
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[26],
              dirty,
              get_default_slot_changes69
            ),
            get_default_slot_context69
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block65.name,
    type: "if",
    source: "(54:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment72(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block65,
    create_if_block_111,
    create_if_block_28,
    create_if_block_38,
    create_if_block_48,
    create_if_block_58
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment72.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance72($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "bottom" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = false } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, ids, getPopoverAttrs } = getCtx12();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(25, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getPopoverAttrs("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(13, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(14, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(15, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(16, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(17, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(18, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(19, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(20, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(21, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(22, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(23, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(24, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(26, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    updatePositioning: updatePositioning6,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    content,
    open,
    ids,
    getPopoverAttrs,
    attrs,
    builder,
    $content,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(13, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(14, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(15, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(16, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(17, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(18, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(19, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(20, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(21, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(22, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(23, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(24, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    8192) {
      $: if (id) {
        ids.popover.content.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$content*/
    33554432) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    33538048) {
      $: updatePositioning6({
        side,
        align,
        sideOffset,
        alignOffset,
        collisionPadding,
        avoidCollisions,
        collisionBoundary,
        sameWidth,
        fitViewport,
        strategy,
        overlap
      });
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $content,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Date_picker_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance72,
      create_fragment72,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 13,
        side: 14,
        align: 15,
        sideOffset: 16,
        alignOffset: 17,
        collisionPadding: 18,
        avoidCollisions: 19,
        collisionBoundary: 20,
        sameWidth: 21,
        fitViewport: 22,
        strategy: 23,
        overlap: 24,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_content",
      options,
      id: create_fragment72.name
    });
  }
  get transition() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_content_default = Date_picker_content;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-field.svelte
var get_default_slot_changes70 = (dirty) => ({
  ids: dirty & /*$idValues*/
  1,
  isInvalid: dirty & /*$localIsInvalid*/
  2
});
var get_default_slot_context70 = (ctx) => ({
  ids: (
    /*$idValues*/
    ctx[0]
  ),
  isInvalid: (
    /*$localIsInvalid*/
    ctx[1]
  )
});
function create_fragment73(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[20].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[19],
    get_default_slot_context70
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues, $localIsInvalid*/
        524291)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[19],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[19]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[19],
              dirty,
              get_default_slot_changes70
            ),
            get_default_slot_context70
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment73.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance73($$self, $$props, $$invalidate) {
  let $idValues;
  let $localIsInvalid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_field", slots, ["default"]);
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { granularity = void 0 } = $$props;
  let { hideTimeZone = void 0 } = $$props;
  let { hourCycle = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  let { validationId = void 0 } = $$props;
  let { descriptionId = void 0 } = $$props;
  const { states: { value: localValue, placeholder: localPlaceholder, isInvalid: localIsInvalid }, updateOption, ids } = setCtx13({
    defaultValue: value,
    defaultPlaceholder: placeholder,
    disabled,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    isDateUnavailable,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(4, value = next2);
      }
      return next2;
    },
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(5, placeholder = next2);
      }
      return next2;
    }
  });
  validate_store(localIsInvalid, "localIsInvalid");
  component_subscribe($$self, localIsInvalid, (value2) => $$invalidate(1, $localIsInvalid = value2));
  const idValues = derived(
    [
      ids.dateField.day,
      ids.dateField.description,
      ids.dateField.dayPeriod,
      ids.dateField.field,
      ids.dateField.hour,
      ids.dateField.minute,
      ids.dateField.month,
      ids.dateField.second,
      ids.dateField.year,
      ids.dateField.validation,
      ids.dateField.label,
      ids.dateField.timeZoneName
    ],
    ([
      $dayId,
      $descriptionId,
      $dayPeriodId,
      $fieldId,
      $hourId,
      $minuteId,
      $monthId,
      $secondId,
      $yearId,
      $validationId,
      $labelId,
      $timeZoneNameId
    ]) => ({
      day: $dayId,
      description: $descriptionId,
      dayPeriod: $dayPeriodId,
      field: $fieldId,
      hour: $hourId,
      minute: $minuteId,
      month: $monthId,
      second: $secondId,
      year: $yearId,
      validation: $validationId,
      label: $labelId,
      timeZoneName: $timeZoneNameId
    })
  );
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value2) => $$invalidate(0, $idValues = value2));
  const writable_props = [
    "value",
    "onValueChange",
    "placeholder",
    "onPlaceholderChange",
    "disabled",
    "isDateUnavailable",
    "granularity",
    "hideTimeZone",
    "hourCycle",
    "locale",
    "maxValue",
    "minValue",
    "readonly",
    "validationId",
    "descriptionId"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Date_picker_field> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("value" in $$props2) $$invalidate(4, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(6, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(5, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(7, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(9, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(10, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(11, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(12, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(13, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(14, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(15, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(16, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(17, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(18, descriptionId = $$props2.descriptionId);
    if ("$$scope" in $$props2) $$invalidate(19, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx13,
    value,
    onValueChange,
    placeholder,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    validationId,
    descriptionId,
    localValue,
    localPlaceholder,
    localIsInvalid,
    updateOption,
    ids,
    idValues,
    $idValues,
    $localIsInvalid
  });
  $$self.$inject_state = ($$props2) => {
    if ("value" in $$props2) $$invalidate(4, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(6, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(5, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(7, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(9, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(10, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(11, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(12, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(13, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(14, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(15, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(16, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(17, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(18, descriptionId = $$props2.descriptionId);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*validationId*/
    131072) {
      $: if (validationId) {
        ids.dateField.validation.set(validationId);
      }
    }
    if ($$self.$$.dirty & /*descriptionId*/
    262144) {
      $: if (descriptionId) {
        ids.dateField.description.set(descriptionId);
      }
    }
    if ($$self.$$.dirty & /*value*/
    16) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*placeholder*/
    32) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty & /*disabled*/
    256) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*isDateUnavailable*/
    512) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty & /*granularity*/
    1024) {
      $: updateOption("granularity", granularity);
    }
    if ($$self.$$.dirty & /*hideTimeZone*/
    2048) {
      $: updateOption("hideTimeZone", hideTimeZone);
    }
    if ($$self.$$.dirty & /*hourCycle*/
    4096) {
      $: updateOption("hourCycle", hourCycle);
    }
    if ($$self.$$.dirty & /*locale*/
    8192) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty & /*maxValue*/
    16384) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty & /*minValue*/
    32768) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty & /*readonly*/
    65536) {
      $: updateOption("readonly", readonly2);
    }
  };
  return [
    $idValues,
    $localIsInvalid,
    localIsInvalid,
    idValues,
    value,
    placeholder,
    onValueChange,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly2,
    validationId,
    descriptionId,
    $$scope,
    slots
  ];
}
var Date_picker_field = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance73, create_fragment73, safe_not_equal, {
      value: 4,
      onValueChange: 6,
      placeholder: 5,
      onPlaceholderChange: 7,
      disabled: 8,
      isDateUnavailable: 9,
      granularity: 10,
      hideTimeZone: 11,
      hourCycle: 12,
      locale: 13,
      maxValue: 14,
      minValue: 15,
      readonly: 16,
      validationId: 17,
      descriptionId: 18
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_field",
      options,
      id: create_fragment73.name
    });
  }
  get value() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get placeholder() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get granularity() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set granularity(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hideTimeZone() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hideTimeZone(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hourCycle() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hourCycle(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get validationId() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set validationId(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get descriptionId() {
    throw new Error("<Date_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set descriptionId(value) {
    throw new Error("<Date_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_field_default = Date_picker_field;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-input.svelte
var file68 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-input.svelte";
var get_default_slot_changes_155 = (dirty) => ({ segments: dirty & /*$segmentContents*/
8 });
var get_default_slot_context_155 = (ctx) => ({
  builder: true,
  segments: (
    /*$segmentContents*/
    ctx[3]
  )
});
var get_default_slot_changes71 = (dirty) => ({ segments: dirty & /*$segmentContents*/
8 });
var get_default_slot_context71 = (ctx) => ({
  builder: true,
  segments: (
    /*$segmentContents*/
    ctx[3]
  )
});
function create_else_block58(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_155
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file68, 25, 1, 488);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $segmentContents*/
        520)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_155
            ),
            get_default_slot_context_155
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block58.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block66(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context71
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $segmentContents*/
        520)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes71
            ),
            get_default_slot_context71
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block66.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment74(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block66, create_else_block58];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment74.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance74($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $field;
  let $segmentContents;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { field }, states: { segmentContents }, ids, getFieldAttrs } = getCtx12();
  validate_store(field, "field");
  component_subscribe($$self, field, (value) => $$invalidate(8, $field = value));
  validate_store(segmentContents, "segmentContents");
  component_subscribe($$self, segmentContents, (value) => $$invalidate(3, $segmentContents = value));
  const attrs = getFieldAttrs("input");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    asChild,
    id,
    el,
    field,
    segmentContents,
    ids,
    getFieldAttrs,
    attrs,
    builder,
    $field,
    $segmentContents
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    128) {
      $: if (id) {
        ids.dateField.field.set(id);
      }
    }
    if ($$self.$$.dirty & /*$field*/
    256) {
      $: $$invalidate(2, builder = $field);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $segmentContents,
    field,
    segmentContents,
    $$restProps,
    id,
    $field,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_picker_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance74, create_fragment74, safe_not_equal, { asChild: 1, id: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_input",
      options,
      id: create_fragment74.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_picker_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_picker_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_input_default = Date_picker_input;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-label.svelte
var file69 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-label.svelte";
var get_default_slot_changes_156 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_156 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes72 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context72 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block59(ctx) {
  let span;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_156
  );
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      var span_nodes = children(span);
      if (default_slot) default_slot.l(span_nodes);
      span_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file69, 23, 1, 422);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      if (default_slot) {
        default_slot.m(span, null);
      }
      ctx[9](span);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_156
            ),
            get_default_slot_context_156
          );
        }
      }
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block59.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block67(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context72
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes72
            ),
            get_default_slot_context72
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block67.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment75(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block67, create_else_block59];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment75.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance75($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $label;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { label }, ids, getFieldAttrs } = getCtx12();
  validate_store(label, "label");
  component_subscribe($$self, label, (value) => $$invalidate(6, $label = value));
  if (id) {
    ids.dateField.label.set(id);
  }
  const attrs = getFieldAttrs("label");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    asChild,
    id,
    el,
    label,
    ids,
    getFieldAttrs,
    attrs,
    builder,
    $label
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$label*/
    64) {
      $: $$invalidate(2, builder = $label);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    label,
    $$restProps,
    id,
    $label,
    $$scope,
    slots,
    span_binding
  ];
}
var Date_picker_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance75, create_fragment75, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_label",
      options,
      id: create_fragment75.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_picker_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_picker_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_label_default = Date_picker_label;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-segment.svelte
var file70 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-segment.svelte";
var get_default_slot_changes_157 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_157 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes73 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context73 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block60(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_157
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file70, 27, 1, 583);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_157
            ),
            get_default_slot_context_157
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block60.name,
    type: "else",
    source: "(27:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block68(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context73
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes73
            ),
            get_default_slot_context73
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block68.name,
    type: "if",
    source: "(25:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment76(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block68, create_else_block60];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment76.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance76($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "part", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $segment;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_segment", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { part } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { segment }, ids, getFieldAttrs } = getCtx12();
  validate_store(segment, "segment");
  component_subscribe($$self, segment, (value) => $$invalidate(8, $segment = value));
  const attrs = getFieldAttrs("segment");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (part === void 0 && !("part" in $$props || $$self.$$.bound[$$self.$$.props["part"]])) {
      console.warn("<Date_picker_segment> was created without expected prop 'part'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("part" in $$new_props) $$invalidate(7, part = $$new_props.part);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    createDispatcher,
    asChild,
    id,
    part,
    el,
    segment,
    ids,
    getFieldAttrs,
    attrs,
    dispatch,
    builder,
    $segment
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("part" in $$props) $$invalidate(7, part = $$new_props.part);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id, part*/
    192) {
      $: if (id && part !== "literal") {
        ids.dateField[part].set(id);
      }
    }
    if ($$self.$$.dirty & /*$segment, part*/
    384) {
      $: $$invalidate(2, builder = $segment(part));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    segment,
    dispatch,
    $$restProps,
    id,
    part,
    $segment,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_picker_segment = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance76, create_fragment76, safe_not_equal, { asChild: 1, id: 6, part: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_segment",
      options,
      id: create_fragment76.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get part() {
    throw new Error("<Date_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set part(value) {
    throw new Error("<Date_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_segment_default = Date_picker_segment;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-trigger.svelte
var file71 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-trigger.svelte";
var get_default_slot_changes_158 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_158 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes74 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context74 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block61(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_158
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file71, 26, 1, 542);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[10](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_158
            ),
            get_default_slot_context_158
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block61.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block69(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context74
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes74
            ),
            get_default_slot_context74
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block69.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment77(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block69, create_else_block61];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment77.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance77($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getPopoverAttrs } = getCtx12();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(7, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getPopoverAttrs("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    ids,
    getPopoverAttrs,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.popover.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    128) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_picker_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance77, create_fragment77, safe_not_equal, { asChild: 1, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_trigger",
      options,
      id: create_fragment77.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_picker_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_picker_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_trigger_default = Date_picker_trigger;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker.svelte
var get_default_slot_changes75 = (dirty) => ({
  ids: dirty[0] & /*$idValues*/
  1,
  isInvalid: dirty[0] & /*$localIsInvalid*/
  2
});
var get_default_slot_context75 = (ctx) => ({
  ids: (
    /*$idValues*/
    ctx[0]
  ),
  isInvalid: (
    /*$localIsInvalid*/
    ctx[1]
  )
});
function create_fragment78(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[29].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[28],
    get_default_slot_context75
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, $idValues, $localIsInvalid*/
        268435459)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[28],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[28]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[28],
              dirty,
              get_default_slot_changes75
            ),
            get_default_slot_context75
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment78.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance78($$self, $$props, $$invalidate) {
  let $idValues;
  let $localIsInvalid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker", slots, ["default"]);
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { granularity = void 0 } = $$props;
  let { hideTimeZone = void 0 } = $$props;
  let { hourCycle = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  let { validationId = void 0 } = $$props;
  let { descriptionId = void 0 } = $$props;
  let { preventDeselect = void 0 } = $$props;
  let { pagedNavigation = void 0 } = $$props;
  let { weekStartsOn = void 0 } = $$props;
  let { isDateDisabled = void 0 } = $$props;
  let { fixedWeeks = void 0 } = $$props;
  let { calendarLabel = void 0 } = $$props;
  let { weekdayFormat = void 0 } = $$props;
  let { numberOfMonths = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { value: localValue, placeholder: localPlaceholder, isInvalid: localIsInvalid }, updateOption, ids } = setCtx13({
    defaultValue: value,
    defaultPlaceholder: placeholder,
    preventDeselect,
    pagedNavigation,
    weekStartsOn,
    isDateDisabled,
    fixedWeeks,
    calendarLabel,
    disabled,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    weekdayFormat,
    numberOfMonths,
    isDateUnavailable,
    onOutsideClick,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(4, value = next2);
      }
      return next2;
    },
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(5, placeholder = next2);
      }
      return next2;
    }
  });
  validate_store(localIsInvalid, "localIsInvalid");
  component_subscribe($$self, localIsInvalid, (value2) => $$invalidate(1, $localIsInvalid = value2));
  const idValues = derived(
    [
      ids.dateField.day,
      ids.dateField.description,
      ids.dateField.dayPeriod,
      ids.dateField.field,
      ids.dateField.hour,
      ids.dateField.minute,
      ids.dateField.month,
      ids.dateField.second,
      ids.dateField.year,
      ids.dateField.validation,
      ids.dateField.label,
      ids.dateField.timeZoneName,
      ids.calendar.calendar,
      ids.popover.content,
      ids.popover.trigger
    ],
    ([
      $dayId,
      $descriptionId,
      $dayPeriodId,
      $fieldId,
      $hourId,
      $minuteId,
      $monthId,
      $secondId,
      $yearId,
      $validationId,
      $labelId,
      $timeZoneNameId,
      $calendarId,
      $contentId
    ]) => ({
      day: $dayId,
      description: $descriptionId,
      dayPeriod: $dayPeriodId,
      field: $fieldId,
      hour: $hourId,
      minute: $minuteId,
      month: $monthId,
      second: $secondId,
      year: $yearId,
      validation: $validationId,
      label: $labelId,
      timeZoneName: $timeZoneNameId,
      calendar: $calendarId,
      content: $contentId
    })
  );
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value2) => $$invalidate(0, $idValues = value2));
  const writable_props = [
    "value",
    "onValueChange",
    "placeholder",
    "onPlaceholderChange",
    "disabled",
    "isDateUnavailable",
    "granularity",
    "hideTimeZone",
    "hourCycle",
    "locale",
    "maxValue",
    "minValue",
    "readonly",
    "validationId",
    "descriptionId",
    "preventDeselect",
    "pagedNavigation",
    "weekStartsOn",
    "isDateDisabled",
    "fixedWeeks",
    "calendarLabel",
    "weekdayFormat",
    "numberOfMonths",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Date_picker> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("value" in $$props2) $$invalidate(4, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(6, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(5, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(7, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(9, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(10, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(11, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(12, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(13, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(14, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(15, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(16, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(17, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(18, descriptionId = $$props2.descriptionId);
    if ("preventDeselect" in $$props2) $$invalidate(19, preventDeselect = $$props2.preventDeselect);
    if ("pagedNavigation" in $$props2) $$invalidate(20, pagedNavigation = $$props2.pagedNavigation);
    if ("weekStartsOn" in $$props2) $$invalidate(21, weekStartsOn = $$props2.weekStartsOn);
    if ("isDateDisabled" in $$props2) $$invalidate(22, isDateDisabled = $$props2.isDateDisabled);
    if ("fixedWeeks" in $$props2) $$invalidate(23, fixedWeeks = $$props2.fixedWeeks);
    if ("calendarLabel" in $$props2) $$invalidate(24, calendarLabel = $$props2.calendarLabel);
    if ("weekdayFormat" in $$props2) $$invalidate(25, weekdayFormat = $$props2.weekdayFormat);
    if ("numberOfMonths" in $$props2) $$invalidate(26, numberOfMonths = $$props2.numberOfMonths);
    if ("onOutsideClick" in $$props2) $$invalidate(27, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(28, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx13,
    value,
    onValueChange,
    placeholder,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    validationId,
    descriptionId,
    preventDeselect,
    pagedNavigation,
    weekStartsOn,
    isDateDisabled,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    numberOfMonths,
    onOutsideClick,
    localValue,
    localPlaceholder,
    localIsInvalid,
    updateOption,
    ids,
    idValues,
    $idValues,
    $localIsInvalid
  });
  $$self.$inject_state = ($$props2) => {
    if ("value" in $$props2) $$invalidate(4, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(6, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(5, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(7, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(8, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(9, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(10, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(11, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(12, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(13, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(14, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(15, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(16, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(17, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(18, descriptionId = $$props2.descriptionId);
    if ("preventDeselect" in $$props2) $$invalidate(19, preventDeselect = $$props2.preventDeselect);
    if ("pagedNavigation" in $$props2) $$invalidate(20, pagedNavigation = $$props2.pagedNavigation);
    if ("weekStartsOn" in $$props2) $$invalidate(21, weekStartsOn = $$props2.weekStartsOn);
    if ("isDateDisabled" in $$props2) $$invalidate(22, isDateDisabled = $$props2.isDateDisabled);
    if ("fixedWeeks" in $$props2) $$invalidate(23, fixedWeeks = $$props2.fixedWeeks);
    if ("calendarLabel" in $$props2) $$invalidate(24, calendarLabel = $$props2.calendarLabel);
    if ("weekdayFormat" in $$props2) $$invalidate(25, weekdayFormat = $$props2.weekdayFormat);
    if ("numberOfMonths" in $$props2) $$invalidate(26, numberOfMonths = $$props2.numberOfMonths);
    if ("onOutsideClick" in $$props2) $$invalidate(27, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*validationId*/
    131072) {
      $: if (validationId) {
        ids.dateField.validation.set(validationId);
      }
    }
    if ($$self.$$.dirty[0] & /*descriptionId*/
    262144) {
      $: if (descriptionId) {
        ids.dateField.description.set(descriptionId);
      }
    }
    if ($$self.$$.dirty[0] & /*value*/
    16) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty[0] & /*placeholder*/
    32) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty[0] & /*disabled*/
    256) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty[0] & /*isDateUnavailable*/
    512) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty[0] & /*granularity*/
    1024) {
      $: updateOption("granularity", granularity);
    }
    if ($$self.$$.dirty[0] & /*hideTimeZone*/
    2048) {
      $: updateOption("hideTimeZone", hideTimeZone);
    }
    if ($$self.$$.dirty[0] & /*hourCycle*/
    4096) {
      $: updateOption("hourCycle", hourCycle);
    }
    if ($$self.$$.dirty[0] & /*locale*/
    8192) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty[0] & /*maxValue*/
    16384) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty[0] & /*minValue*/
    32768) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty[0] & /*readonly*/
    65536) {
      $: updateOption("readonly", readonly2);
    }
    if ($$self.$$.dirty[0] & /*fixedWeeks*/
    8388608) {
      $: updateOption("fixedWeeks", fixedWeeks);
    }
    if ($$self.$$.dirty[0] & /*preventDeselect*/
    524288) {
      $: updateOption("preventDeselect", preventDeselect);
    }
    if ($$self.$$.dirty[0] & /*pagedNavigation*/
    1048576) {
      $: updateOption("pagedNavigation", pagedNavigation);
    }
    if ($$self.$$.dirty[0] & /*weekStartsOn*/
    2097152) {
      $: updateOption("weekStartsOn", weekStartsOn);
    }
    if ($$self.$$.dirty[0] & /*isDateDisabled*/
    4194304) {
      $: updateOption("isDateDisabled", isDateDisabled);
    }
    if ($$self.$$.dirty[0] & /*calendarLabel*/
    16777216) {
      $: updateOption("calendarLabel", calendarLabel);
    }
    if ($$self.$$.dirty[0] & /*weekdayFormat*/
    33554432) {
      $: updateOption("weekdayFormat", weekdayFormat);
    }
    if ($$self.$$.dirty[0] & /*numberOfMonths*/
    67108864) {
      $: updateOption("numberOfMonths", numberOfMonths);
    }
    if ($$self.$$.dirty[0] & /*onOutsideClick*/
    134217728) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    $localIsInvalid,
    localIsInvalid,
    idValues,
    value,
    placeholder,
    onValueChange,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly2,
    validationId,
    descriptionId,
    preventDeselect,
    pagedNavigation,
    weekStartsOn,
    isDateDisabled,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    numberOfMonths,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Date_picker = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance78,
      create_fragment78,
      safe_not_equal,
      {
        value: 4,
        onValueChange: 6,
        placeholder: 5,
        onPlaceholderChange: 7,
        disabled: 8,
        isDateUnavailable: 9,
        granularity: 10,
        hideTimeZone: 11,
        hourCycle: 12,
        locale: 13,
        maxValue: 14,
        minValue: 15,
        readonly: 16,
        validationId: 17,
        descriptionId: 18,
        preventDeselect: 19,
        pagedNavigation: 20,
        weekStartsOn: 21,
        isDateDisabled: 22,
        fixedWeeks: 23,
        calendarLabel: 24,
        weekdayFormat: 25,
        numberOfMonths: 26,
        onOutsideClick: 27
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker",
      options,
      id: create_fragment78.name
    });
  }
  get value() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get placeholder() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get granularity() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set granularity(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hideTimeZone() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hideTimeZone(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hourCycle() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hourCycle(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get validationId() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set validationId(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get descriptionId() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set descriptionId(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventDeselect() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventDeselect(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get pagedNavigation() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set pagedNavigation(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekStartsOn() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekStartsOn(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateDisabled() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateDisabled(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fixedWeeks() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fixedWeeks(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get calendarLabel() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set calendarLabel(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekdayFormat() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekdayFormat(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get numberOfMonths() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set numberOfMonths(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Date_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Date_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_default = Date_picker;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid-body.svelte
var file72 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid-body.svelte";
var get_default_slot_changes_159 = (dirty) => ({});
var get_default_slot_context_159 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes76 = (dirty) => ({});
var get_default_slot_context76 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block62(ctx) {
  let tbody;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_159
  );
  let tbody_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tbody_data = {};
  for (let i = 0; i < tbody_levels.length; i += 1) {
    tbody_data = assign(tbody_data, tbody_levels[i]);
  }
  const block = {
    c: function create() {
      tbody = element("tbody");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tbody = claim_element(nodes, "TBODY", {});
      var tbody_nodes = children(tbody);
      if (default_slot) default_slot.l(tbody_nodes);
      tbody_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tbody, tbody_data);
      add_location(tbody, file72, 10, 1, 232);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tbody, anchor);
      if (default_slot) {
        default_slot.m(tbody, null);
      }
      ctx[6](tbody);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_159
            ),
            get_default_slot_context_159
          );
        }
      }
      set_attributes(tbody, tbody_data = get_spread_update(tbody_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tbody);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block62.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block70(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context76
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes76
            ),
            get_default_slot_context76
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block70.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment79(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block70, create_else_block62];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment79.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance79($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_grid_body", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx12();
  const attrs = getCalendarAttrs("grid-body");
  function tbody_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx12,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tbody_binding];
}
var Date_picker_grid_body = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance79, create_fragment79, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_grid_body",
      options,
      id: create_fragment79.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_grid_body_default = Date_picker_grid_body;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid-head.svelte
var file73 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid-head.svelte";
var get_default_slot_changes_160 = (dirty) => ({});
var get_default_slot_context_160 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes77 = (dirty) => ({});
var get_default_slot_context77 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block63(ctx) {
  let thead;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_160
  );
  let thead_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let thead_data = {};
  for (let i = 0; i < thead_levels.length; i += 1) {
    thead_data = assign(thead_data, thead_levels[i]);
  }
  const block = {
    c: function create() {
      thead = element("thead");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      thead = claim_element(nodes, "THEAD", {});
      var thead_nodes = children(thead);
      if (default_slot) default_slot.l(thead_nodes);
      thead_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(thead, thead_data);
      add_location(thead, file73, 13, 1, 264);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, thead, anchor);
      if (default_slot) {
        default_slot.m(thead, null);
      }
      ctx[6](thead);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_160
            ),
            get_default_slot_context_160
          );
        }
      }
      set_attributes(thead, thead_data = get_spread_update(thead_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(thead);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block63.name,
    type: "else",
    source: "(13:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block71(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context77
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes77
            ),
            get_default_slot_context77
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block71.name,
    type: "if",
    source: "(11:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment80(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block71, create_else_block63];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment80.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance80($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_grid_head", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx12();
  const attrs = {
    ...getCalendarAttrs("grid-head"),
    "aria-hidden": true
  };
  function thead_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx12,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, thead_binding];
}
var Date_picker_grid_head = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance80, create_fragment80, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_grid_head",
      options,
      id: create_fragment80.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_grid_head_default = Date_picker_grid_head;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid-row.svelte
var file74 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid-row.svelte";
var get_default_slot_changes_161 = (dirty) => ({});
var get_default_slot_context_161 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes78 = (dirty) => ({});
var get_default_slot_context78 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block64(ctx) {
  let tr;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_161
  );
  let tr_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tr_data = {};
  for (let i = 0; i < tr_levels.length; i += 1) {
    tr_data = assign(tr_data, tr_levels[i]);
  }
  const block = {
    c: function create() {
      tr = element("tr");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tr = claim_element(nodes, "TR", {});
      var tr_nodes = children(tr);
      if (default_slot) default_slot.l(tr_nodes);
      tr_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tr, tr_data);
      add_location(tr, file74, 10, 1, 231);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tr, anchor);
      if (default_slot) {
        default_slot.m(tr, null);
      }
      ctx[6](tr);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_161
            ),
            get_default_slot_context_161
          );
        }
      }
      set_attributes(tr, tr_data = get_spread_update(tr_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tr);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block64.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block72(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context78
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes78
            ),
            get_default_slot_context78
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block72.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment81(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block72, create_else_block64];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment81.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance81($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_grid_row", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx12();
  const attrs = getCalendarAttrs("grid-row");
  function tr_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx12,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tr_binding];
}
var Date_picker_grid_row = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance81, create_fragment81, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_grid_row",
      options,
      id: create_fragment81.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_grid_row_default = Date_picker_grid_row;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-head-cell.svelte
var file75 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-head-cell.svelte";
var get_default_slot_changes_162 = (dirty) => ({});
var get_default_slot_context_162 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes79 = (dirty) => ({});
var get_default_slot_context79 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block65(ctx) {
  let th;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_162
  );
  let th_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let th_data = {};
  for (let i = 0; i < th_levels.length; i += 1) {
    th_data = assign(th_data, th_levels[i]);
  }
  const block = {
    c: function create() {
      th = element("th");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      th = claim_element(nodes, "TH", {});
      var th_nodes = children(th);
      if (default_slot) default_slot.l(th_nodes);
      th_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(th, th_data);
      add_location(th, file75, 10, 1, 232);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, th, anchor);
      if (default_slot) {
        default_slot.m(th, null);
      }
      ctx[6](th);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_162
            ),
            get_default_slot_context_162
          );
        }
      }
      set_attributes(th, th_data = get_spread_update(th_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(th);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block65.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block73(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context79
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes79
            ),
            get_default_slot_context79
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block73.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment82(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block73, create_else_block65];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment82.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance82($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_head_cell", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx12();
  const attrs = getCalendarAttrs("head-cell");
  function th_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx12,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, th_binding];
}
var Date_picker_head_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance82, create_fragment82, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_head_cell",
      options,
      id: create_fragment82.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_head_cell_default = Date_picker_head_cell;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-header.svelte
var file76 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-header.svelte";
var get_default_slot_changes_163 = (dirty) => ({});
var get_default_slot_context_163 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes80 = (dirty) => ({});
var get_default_slot_context80 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block66(ctx) {
  let header;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_163
  );
  let header_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let header_data = {};
  for (let i = 0; i < header_levels.length; i += 1) {
    header_data = assign(header_data, header_levels[i]);
  }
  const block = {
    c: function create() {
      header = element("header");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      header = claim_element(nodes, "HEADER", {});
      var header_nodes = children(header);
      if (default_slot) default_slot.l(header_nodes);
      header_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(header, header_data);
      add_location(header, file76, 10, 1, 229);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, header, anchor);
      if (default_slot) {
        default_slot.m(header, null);
      }
      ctx[6](header);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_163
            ),
            get_default_slot_context_163
          );
        }
      }
      set_attributes(header, header_data = get_spread_update(header_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(header);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block66.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block74(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context80
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes80
            ),
            get_default_slot_context80
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block74.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment83(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block74, create_else_block66];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment83.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance83($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_header", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx12();
  const attrs = getCalendarAttrs("header");
  function header_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx12,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, header_binding];
}
var Date_picker_header = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance83, create_fragment83, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_header",
      options,
      id: create_fragment83.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_header_default = Date_picker_header;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-cell.svelte
var file77 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-cell.svelte";
var get_default_slot_changes_164 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context_164 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes81 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context81 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block67(ctx) {
  let td;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_164
  );
  let td_levels = [
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[2]
  ];
  let td_data = {};
  for (let i = 0; i < td_levels.length; i += 1) {
    td_data = assign(td_data, td_levels[i]);
  }
  const block = {
    c: function create() {
      td = element("td");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      td = claim_element(nodes, "TD", {});
      var td_nodes = children(td);
      if (default_slot) default_slot.l(td_nodes);
      td_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(td, td_data);
      add_location(td, file77, 20, 1, 460);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, td, anchor);
      if (default_slot) {
        default_slot.m(td, null);
      }
      ctx[11](td);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_164
            ),
            get_default_slot_context_164
          );
        }
      }
      set_attributes(td, td_data = get_spread_update(td_levels, [
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        dirty & /*attrs*/
        4 && /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(td);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block67.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block75(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context81
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes81
            ),
            get_default_slot_context81
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block75.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment84(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block75, create_else_block67];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment84.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance84($$self, $$props, $$invalidate) {
  let attrs;
  const omit_props_names = ["date", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateDisabled;
  let $isDateUnavailable;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_cell", slots, ["default"]);
  let { date } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { helpers: { isDateDisabled, isDateUnavailable }, getCalendarAttrs } = getCtx12();
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(7, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(8, $isDateUnavailable = value));
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Date_picker_cell> was created without expected prop 'date'");
    }
  });
  function td_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx12,
    date,
    asChild,
    el,
    isDateDisabled,
    isDateUnavailable,
    getCalendarAttrs,
    attrs,
    $isDateDisabled,
    $isDateUnavailable
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(2, attrs = $$new_props.attrs);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$isDateDisabled, date, $isDateUnavailable*/
    448) {
      $: $$invalidate(2, attrs = {
        ...getCalendarAttrs("cell"),
        "aria-disabled": $isDateDisabled(date) || $isDateUnavailable(date),
        "data-disabled": $isDateDisabled(date) ? "" : void 0,
        role: "gridcell"
      });
    }
  };
  return [
    el,
    asChild,
    attrs,
    isDateDisabled,
    isDateUnavailable,
    $$restProps,
    date,
    $isDateDisabled,
    $isDateUnavailable,
    $$scope,
    slots,
    td_binding
  ];
}
var Date_picker_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance84, create_fragment84, safe_not_equal, { date: 6, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_cell",
      options,
      id: create_fragment84.name
    });
  }
  get date() {
    throw new Error("<Date_picker_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Date_picker_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Date_picker_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_cell_default = Date_picker_cell;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-day.svelte
var file78 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-day.svelte";
var get_default_slot_changes_165 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  64,
  unavailable: dirty & /*unavailable*/
  32,
  selected: dirty & /*selected*/
  16
});
var get_default_slot_context_165 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[6]
  ),
  unavailable: (
    /*unavailable*/
    ctx[5]
  ),
  selected: (
    /*selected*/
    ctx[4]
  )
});
var get_default_slot_changes82 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  64,
  unavailable: dirty & /*unavailable*/
  32,
  selected: dirty & /*selected*/
  16
});
var get_default_slot_context82 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[6]
  ),
  unavailable: (
    /*unavailable*/
    ctx[5]
  ),
  selected: (
    /*selected*/
    ctx[4]
  )
});
function create_else_block68(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[19].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[18],
    get_default_slot_context_165
  );
  const default_slot_or_fallback = default_slot || fallback_block4(ctx);
  let div_levels = [
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file78, 29, 1, 724);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[20](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[3].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[11],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable, selected*/
        262264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[18],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[18]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[18],
              dirty,
              get_default_slot_changes_165
            ),
            get_default_slot_context_165
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*date*/
        2)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[20](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block68.name,
    type: "else",
    source: "(29:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block76(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[19].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[18],
    get_default_slot_context82
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable, selected*/
        262264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[18],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[18]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[18],
              dirty,
              get_default_slot_changes82
            ),
            get_default_slot_context82
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block76.name,
    type: "if",
    source: "(27:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block4(ctx) {
  let t_value = (
    /*date*/
    ctx[1].day + ""
  );
  let t;
  const block = {
    c: function create() {
      t = text(t_value);
    },
    l: function claim(nodes) {
      t = claim_text(nodes, t_value);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*date*/
      2 && t_value !== (t_value = /*date*/
      ctx2[1].day + "")) set_data_dev(t, t_value);
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block4.name,
    type: "fallback",
    source: "(31:54)     ",
    ctx
  });
  return block;
}
function create_fragment85(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block76, create_else_block68];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment85.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance85($$self, $$props, $$invalidate) {
  let builder;
  let disabled;
  let unavailable;
  let selected;
  const omit_props_names = ["date", "month", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateSelected;
  let $isDateUnavailable;
  let $isDateDisabled;
  let $cell;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_day", slots, ["default"]);
  let { date } = $$props;
  let { month } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { cell }, helpers: { isDateDisabled, isDateUnavailable, isDateSelected }, getCalendarAttrs } = getCtx12();
  validate_store(cell, "cell");
  component_subscribe($$self, cell, (value) => $$invalidate(17, $cell = value));
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(16, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(15, $isDateUnavailable = value));
  validate_store(isDateSelected, "isDateSelected");
  component_subscribe($$self, isDateSelected, (value) => $$invalidate(14, $isDateSelected = value));
  const attrs = getCalendarAttrs("day");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Date_picker_day> was created without expected prop 'date'");
    }
    if (month === void 0 && !("month" in $$props || $$self.$$.bound[$$self.$$.props["month"]])) {
      console.warn("<Date_picker_day> was created without expected prop 'month'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$new_props) $$invalidate(13, month = $$new_props.month);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(18, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    createDispatcher,
    date,
    month,
    asChild,
    el,
    cell,
    isDateDisabled,
    isDateUnavailable,
    isDateSelected,
    getCalendarAttrs,
    attrs,
    dispatch,
    selected,
    unavailable,
    disabled,
    builder,
    $isDateSelected,
    $isDateUnavailable,
    $isDateDisabled,
    $cell
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$props) $$invalidate(13, month = $$new_props.month);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("selected" in $$props) $$invalidate(4, selected = $$new_props.selected);
    if ("unavailable" in $$props) $$invalidate(5, unavailable = $$new_props.unavailable);
    if ("disabled" in $$props) $$invalidate(6, disabled = $$new_props.disabled);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$cell, date, month*/
    139266) {
      $: $$invalidate(3, builder = $cell(date, month));
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$isDateDisabled, date*/
    65538) {
      $: $$invalidate(6, disabled = $isDateDisabled(date));
    }
    if ($$self.$$.dirty & /*$isDateUnavailable, date*/
    32770) {
      $: $$invalidate(5, unavailable = $isDateUnavailable(date));
    }
    if ($$self.$$.dirty & /*$isDateSelected, date*/
    16386) {
      $: $$invalidate(4, selected = $isDateSelected(date));
    }
  };
  return [
    el,
    date,
    asChild,
    builder,
    selected,
    unavailable,
    disabled,
    cell,
    isDateDisabled,
    isDateUnavailable,
    isDateSelected,
    dispatch,
    $$restProps,
    month,
    $isDateSelected,
    $isDateUnavailable,
    $isDateDisabled,
    $cell,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_picker_day = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance85, create_fragment85, safe_not_equal, { date: 1, month: 13, asChild: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_day",
      options,
      id: create_fragment85.name
    });
  }
  get date() {
    throw new Error("<Date_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Date_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get month() {
    throw new Error("<Date_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set month(value) {
    throw new Error("<Date_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Date_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_day_default = Date_picker_day;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid.svelte
var file79 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-grid.svelte";
var get_default_slot_changes_166 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_166 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes83 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context83 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block69(ctx) {
  let table;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_166
  );
  let table_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let table_data = {};
  for (let i = 0; i < table_levels.length; i += 1) {
    table_data = assign(table_data, table_levels[i]);
  }
  const block = {
    c: function create() {
      table = element("table");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      table = claim_element(nodes, "TABLE", {});
      var table_nodes = children(table);
      if (default_slot) default_slot.l(table_nodes);
      table_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(table, table_data);
      add_location(table, file79, 18, 1, 351);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, table, anchor);
      if (default_slot) {
        default_slot.m(table, null);
      }
      ctx[8](table);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(table));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_166
            ),
            get_default_slot_context_166
          );
        }
      }
      set_attributes(table, table_data = get_spread_update(table_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(table);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block69.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block77(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context83
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes83
            ),
            get_default_slot_context83
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block77.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment86(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block77, create_else_block69];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment86.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance86($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $grid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_grid", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { grid }, getCalendarAttrs } = getCtx12();
  validate_store(grid, "grid");
  component_subscribe($$self, grid, (value) => $$invalidate(5, $grid = value));
  const attrs = getCalendarAttrs("grid");
  function table_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    asChild,
    el,
    grid,
    getCalendarAttrs,
    attrs,
    builder,
    $grid
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$grid*/
    32) {
      $: $$invalidate(2, builder = $grid);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, grid, $$restProps, $grid, $$scope, slots, table_binding];
}
var Date_picker_grid = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance86, create_fragment86, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_grid",
      options,
      id: create_fragment86.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_grid_default = Date_picker_grid;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-heading.svelte
var file80 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-heading.svelte";
var get_default_slot_changes_167 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context_167 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
var get_default_slot_changes84 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context84 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
function create_else_block70(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_167
  );
  const default_slot_or_fallback = default_slot || fallback_block5(ctx);
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file80, 19, 1, 417);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_167
            ),
            get_default_slot_context_167
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*$headingValue*/
        8)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block70.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block78(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context84
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes84
            ),
            get_default_slot_context84
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block78.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block5(ctx) {
  let t;
  const block = {
    c: function create() {
      t = text(
        /*$headingValue*/
        ctx[3]
      );
    },
    l: function claim(nodes) {
      t = claim_text(
        nodes,
        /*$headingValue*/
        ctx[3]
      );
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*$headingValue*/
      8) set_data_dev(
        t,
        /*$headingValue*/
        ctx2[3]
      );
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block5.name,
    type: "fallback",
    source: "(21:47)     ",
    ctx
  });
  return block;
}
function create_fragment87(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block78, create_else_block70];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment87.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance87($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $heading;
  let $headingValue;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_heading", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { heading }, states: { headingValue }, getCalendarAttrs } = getCtx12();
  validate_store(heading, "heading");
  component_subscribe($$self, heading, (value) => $$invalidate(7, $heading = value));
  validate_store(headingValue, "headingValue");
  component_subscribe($$self, headingValue, (value) => $$invalidate(3, $headingValue = value));
  const attrs = getCalendarAttrs("heading");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    asChild,
    el,
    heading,
    headingValue,
    getCalendarAttrs,
    attrs,
    builder,
    $heading,
    $headingValue
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$heading*/
    128) {
      $: $$invalidate(2, builder = $heading);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $headingValue,
    heading,
    headingValue,
    $$restProps,
    $heading,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_picker_heading = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance87, create_fragment87, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_heading",
      options,
      id: create_fragment87.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_heading_default = Date_picker_heading;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-next-button.svelte
var file81 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-next-button.svelte";
var get_default_slot_changes_168 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_168 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes85 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context85 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block71(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_168
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file81, 20, 1, 471);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_168
            ),
            get_default_slot_context_168
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block71.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block79(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context85
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes85
            ),
            get_default_slot_context85
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block79.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment88(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block79, create_else_block71];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment88.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance88($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $nextButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_next_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { nextButton }, getCalendarAttrs } = getCtx12();
  validate_store(nextButton, "nextButton");
  component_subscribe($$self, nextButton, (value) => $$invalidate(6, $nextButton = value));
  const attrs = getCalendarAttrs("next-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    createDispatcher,
    asChild,
    el,
    nextButton,
    getCalendarAttrs,
    attrs,
    dispatch,
    builder,
    $nextButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$nextButton*/
    64) {
      $: $$invalidate(2, builder = $nextButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    nextButton,
    dispatch,
    $$restProps,
    $nextButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_picker_next_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance88, create_fragment88, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_next_button",
      options,
      id: create_fragment88.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_next_button_default = Date_picker_next_button;

// node_modules/bits-ui/dist/bits/date-picker/components/date-picker-prev-button.svelte
var file82 = "node_modules/bits-ui/dist/bits/date-picker/components/date-picker-prev-button.svelte";
var get_default_slot_changes_169 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_169 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes86 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context86 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block72(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_169
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file82, 20, 1, 471);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_169
            ),
            get_default_slot_context_169
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block72.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block80(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context86
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes86
            ),
            get_default_slot_context86
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block80.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment89(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block80, create_else_block72];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment89.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance89($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $prevButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_picker_prev_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { prevButton }, getCalendarAttrs } = getCtx12();
  validate_store(prevButton, "prevButton");
  component_subscribe($$self, prevButton, (value) => $$invalidate(6, $prevButton = value));
  const attrs = getCalendarAttrs("prev-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx12,
    createDispatcher,
    asChild,
    el,
    prevButton,
    getCalendarAttrs,
    attrs,
    dispatch,
    builder,
    $prevButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$prevButton*/
    64) {
      $: $$invalidate(2, builder = $prevButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    prevButton,
    dispatch,
    $$restProps,
    $prevButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_picker_prev_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance89, create_fragment89, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_picker_prev_button",
      options,
      id: create_fragment89.name
    });
  }
  get asChild() {
    throw new Error("<Date_picker_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_picker_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_picker_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_picker_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_picker_prev_button_default = Date_picker_prev_button;

// node_modules/bits-ui/dist/bits/date-range-field/index.js
var date_range_field_exports = {};
__export(date_range_field_exports, {
  Input: () => date_range_field_input_default,
  Label: () => date_range_field_label_default,
  Root: () => date_range_field_default,
  Segment: () => date_range_field_segment_default
});

// node_modules/bits-ui/dist/bits/date-range-field/ctx.js
function setCtx14(props) {
  const { NAME, PARTS } = getDateFieldData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const dateRangeField = { ...createDateRangeField(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, dateRangeField);
  return {
    ...dateRangeField,
    updateOption: getOptionUpdater(dateRangeField.options)
  };
}
function getCtx13() {
  const { NAME } = getDateFieldData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/date-range-field/components/date-range-field.svelte
var get_default_slot_changes87 = (dirty) => ({
  isInvalid: dirty & /*$localIsInvalid*/
  2,
  ids: dirty & /*idSlotProp*/
  1
});
var get_default_slot_context87 = (ctx) => ({
  isInvalid: (
    /*$localIsInvalid*/
    ctx[1]
  ),
  ids: (
    /*idSlotProp*/
    ctx[0]
  )
});
function create_fragment90(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[26].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[25],
    get_default_slot_context87
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $localIsInvalid, idSlotProp*/
        33554435)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[25],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[25]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[25],
              dirty,
              get_default_slot_changes87
            ),
            get_default_slot_context87
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment90.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance90($$self, $$props, $$invalidate) {
  let idSlotProp;
  let $fieldIdValues;
  let $endIdValues;
  let $startIdValues;
  let $localIsInvalid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_field", slots, ["default"]);
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { granularity = void 0 } = $$props;
  let { hideTimeZone = void 0 } = $$props;
  let { hourCycle = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  let { validationId = void 0 } = $$props;
  let { descriptionId = void 0 } = $$props;
  let { readonlySegments = void 0 } = $$props;
  const { states: { value: localValue, placeholder: localPlaceholder, isInvalid: localIsInvalid }, updateOption, ids } = setCtx14({
    defaultValue: value,
    defaultPlaceholder: placeholder,
    disabled,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    isDateUnavailable,
    readonlySegments,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(6, value = next2);
      }
      return next2;
    },
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(7, placeholder = next2);
      }
      return next2;
    }
  });
  validate_store(localIsInvalid, "localIsInvalid");
  component_subscribe($$self, localIsInvalid, (value2) => $$invalidate(1, $localIsInvalid = value2));
  const startIdValues = derived(
    [
      ids.start.day,
      ids.start.description,
      ids.start.dayPeriod,
      ids.start.hour,
      ids.start.minute,
      ids.start.month,
      ids.start.second,
      ids.start.year,
      ids.start.validation,
      ids.start.label,
      ids.start.timeZoneName
    ],
    ([
      $dayId,
      $descriptionId,
      $dayPeriodId,
      $hourId,
      $minuteId,
      $monthId,
      $secondId,
      $yearId,
      $validationId,
      $labelId,
      $timeZoneNameId
    ]) => ({
      day: $dayId,
      description: $descriptionId,
      dayPeriod: $dayPeriodId,
      hour: $hourId,
      minute: $minuteId,
      month: $monthId,
      second: $secondId,
      year: $yearId,
      validation: $validationId,
      label: $labelId,
      timeZoneName: $timeZoneNameId
    })
  );
  validate_store(startIdValues, "startIdValues");
  component_subscribe($$self, startIdValues, (value2) => $$invalidate(24, $startIdValues = value2));
  const endIdValues = derived(
    [
      ids.end.day,
      ids.end.description,
      ids.end.dayPeriod,
      ids.end.hour,
      ids.end.minute,
      ids.end.month,
      ids.end.second,
      ids.end.year,
      ids.end.validation,
      ids.end.label,
      ids.end.timeZoneName
    ],
    ([
      $dayId,
      $descriptionId,
      $dayPeriodId,
      $hourId,
      $minuteId,
      $monthId,
      $secondId,
      $yearId,
      $validationId,
      $labelId,
      $timeZoneNameId
    ]) => ({
      day: $dayId,
      description: $descriptionId,
      dayPeriod: $dayPeriodId,
      hour: $hourId,
      minute: $minuteId,
      month: $monthId,
      second: $secondId,
      year: $yearId,
      validation: $validationId,
      label: $labelId,
      timeZoneName: $timeZoneNameId
    })
  );
  validate_store(endIdValues, "endIdValues");
  component_subscribe($$self, endIdValues, (value2) => $$invalidate(23, $endIdValues = value2));
  const fieldIdValues = derived([ids.field.description, ids.field.field, ids.field.label, ids.field.validation], ([$descriptionId, $fieldId, $labelId, $validationId]) => ({
    description: $descriptionId,
    field: $fieldId,
    label: $labelId,
    validation: $validationId
  }));
  validate_store(fieldIdValues, "fieldIdValues");
  component_subscribe($$self, fieldIdValues, (value2) => $$invalidate(22, $fieldIdValues = value2));
  const writable_props = [
    "value",
    "onValueChange",
    "placeholder",
    "onPlaceholderChange",
    "disabled",
    "isDateUnavailable",
    "granularity",
    "hideTimeZone",
    "hourCycle",
    "locale",
    "maxValue",
    "minValue",
    "readonly",
    "validationId",
    "descriptionId",
    "readonlySegments"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Date_range_field> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("value" in $$props2) $$invalidate(6, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(8, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(7, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(9, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(10, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(11, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(12, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(13, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(14, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(15, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(16, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(17, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(18, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(19, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(20, descriptionId = $$props2.descriptionId);
    if ("readonlySegments" in $$props2) $$invalidate(21, readonlySegments = $$props2.readonlySegments);
    if ("$$scope" in $$props2) $$invalidate(25, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx14,
    value,
    onValueChange,
    placeholder,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    validationId,
    descriptionId,
    readonlySegments,
    localValue,
    localPlaceholder,
    localIsInvalid,
    updateOption,
    ids,
    startIdValues,
    endIdValues,
    fieldIdValues,
    idSlotProp,
    $fieldIdValues,
    $endIdValues,
    $startIdValues,
    $localIsInvalid
  });
  $$self.$inject_state = ($$props2) => {
    if ("value" in $$props2) $$invalidate(6, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(8, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(7, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(9, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(10, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(11, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(12, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(13, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(14, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(15, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(16, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(17, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(18, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(19, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(20, descriptionId = $$props2.descriptionId);
    if ("readonlySegments" in $$props2) $$invalidate(21, readonlySegments = $$props2.readonlySegments);
    if ("idSlotProp" in $$props2) $$invalidate(0, idSlotProp = $$props2.idSlotProp);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*descriptionId*/
    1048576) {
      $: if (descriptionId) {
        ids.field.description.set(descriptionId);
      }
    }
    if ($$self.$$.dirty & /*validationId*/
    524288) {
      $: if (validationId) {
        ids.field.validation.set(validationId);
      }
    }
    if ($$self.$$.dirty & /*value*/
    64) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*placeholder*/
    128) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty & /*disabled*/
    1024) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*isDateUnavailable*/
    2048) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty & /*granularity*/
    4096) {
      $: updateOption("granularity", granularity);
    }
    if ($$self.$$.dirty & /*hideTimeZone*/
    8192) {
      $: updateOption("hideTimeZone", hideTimeZone);
    }
    if ($$self.$$.dirty & /*hourCycle*/
    16384) {
      $: updateOption("hourCycle", hourCycle);
    }
    if ($$self.$$.dirty & /*locale*/
    32768) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty & /*maxValue*/
    65536) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty & /*minValue*/
    131072) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty & /*readonly*/
    262144) {
      $: updateOption("readonly", readonly2);
    }
    if ($$self.$$.dirty & /*readonlySegments*/
    2097152) {
      $: updateOption("readonlySegments", readonlySegments);
    }
    if ($$self.$$.dirty & /*$startIdValues, $endIdValues, $fieldIdValues*/
    29360128) {
      $: $$invalidate(0, idSlotProp = {
        start: $startIdValues,
        end: $endIdValues,
        field: $fieldIdValues
      });
    }
  };
  return [
    idSlotProp,
    $localIsInvalid,
    localIsInvalid,
    startIdValues,
    endIdValues,
    fieldIdValues,
    value,
    placeholder,
    onValueChange,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly2,
    validationId,
    descriptionId,
    readonlySegments,
    $fieldIdValues,
    $endIdValues,
    $startIdValues,
    $$scope,
    slots
  ];
}
var Date_range_field = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance90, create_fragment90, safe_not_equal, {
      value: 6,
      onValueChange: 8,
      placeholder: 7,
      onPlaceholderChange: 9,
      disabled: 10,
      isDateUnavailable: 11,
      granularity: 12,
      hideTimeZone: 13,
      hourCycle: 14,
      locale: 15,
      maxValue: 16,
      minValue: 17,
      readonly: 18,
      validationId: 19,
      descriptionId: 20,
      readonlySegments: 21
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_field",
      options,
      id: create_fragment90.name
    });
  }
  get value() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get placeholder() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get granularity() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set granularity(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hideTimeZone() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hideTimeZone(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hourCycle() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hourCycle(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get validationId() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set validationId(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get descriptionId() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set descriptionId(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonlySegments() {
    throw new Error("<Date_range_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonlySegments(value) {
    throw new Error("<Date_range_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_field_default = Date_range_field;

// node_modules/bits-ui/dist/bits/date-range-field/components/date-range-field-input.svelte
var file83 = "node_modules/bits-ui/dist/bits/date-range-field/components/date-range-field-input.svelte";
var get_default_slot_changes_170 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  segments: dirty & /*segments*/
  8
});
var get_default_slot_context_170 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  segments: (
    /*segments*/
    ctx[3]
  )
});
var get_default_slot_changes88 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  segments: dirty & /*segments*/
  8
});
var get_default_slot_context88 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  segments: (
    /*segments*/
    ctx[3]
  )
});
function create_else_block73(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_170
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file83, 30, 1, 547);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[12](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, segments*/
        1036)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_170
            ),
            get_default_slot_context_170
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block73.name,
    type: "else",
    source: "(30:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block81(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context88
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, segments*/
        1036)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes88
            ),
            get_default_slot_context88
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block81.name,
    type: "if",
    source: "(28:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment91(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block81, create_else_block73];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment91.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance91($$self, $$props, $$invalidate) {
  let builder;
  let segments;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $segmentContents;
  let $field;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_field_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { field }, states: { segmentContents }, ids, getAttrs: getAttrs2 } = getCtx13();
  validate_store(field, "field");
  component_subscribe($$self, field, (value) => $$invalidate(9, $field = value));
  validate_store(segmentContents, "segmentContents");
  component_subscribe($$self, segmentContents, (value) => $$invalidate(8, $segmentContents = value));
  const attrs = getAttrs2("input");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx13,
    asChild,
    id,
    el,
    field,
    segmentContents,
    ids,
    getAttrs: getAttrs2,
    attrs,
    segments,
    builder,
    $segmentContents,
    $field
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("segments" in $$props) $$invalidate(3, segments = $$new_props.segments);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    128) {
      $: if (id) {
        ids.field.field.set(id);
      }
    }
    if ($$self.$$.dirty & /*$field*/
    512) {
      $: $$invalidate(2, builder = $field);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$segmentContents*/
    256) {
      $: $$invalidate(3, segments = {
        start: $segmentContents.start,
        end: $segmentContents.end
      });
    }
  };
  return [
    el,
    asChild,
    builder,
    segments,
    field,
    segmentContents,
    $$restProps,
    id,
    $segmentContents,
    $field,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_field_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance91, create_fragment91, safe_not_equal, { asChild: 1, id: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_field_input",
      options,
      id: create_fragment91.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_field_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_field_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_field_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_field_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_field_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_field_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_field_input_default = Date_range_field_input;

// node_modules/bits-ui/dist/bits/date-range-field/components/date-range-field-label.svelte
var file84 = "node_modules/bits-ui/dist/bits/date-range-field/components/date-range-field-label.svelte";
var get_default_slot_changes_171 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_171 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes89 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context89 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block74(ctx) {
  let span;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_171
  );
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      var span_nodes = children(span);
      if (default_slot) default_slot.l(span_nodes);
      span_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file84, 23, 1, 408);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      if (default_slot) {
        default_slot.m(span, null);
      }
      ctx[9](span);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_171
            ),
            get_default_slot_context_171
          );
        }
      }
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block74.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block82(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context89
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes89
            ),
            get_default_slot_context89
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block82.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment92(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block82, create_else_block74];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment92.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance92($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $label;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_field_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { label }, ids, getAttrs: getAttrs2 } = getCtx13();
  validate_store(label, "label");
  component_subscribe($$self, label, (value) => $$invalidate(6, $label = value));
  if (id) {
    ids.field.label.set(id);
  }
  const attrs = getAttrs2("label");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx13,
    asChild,
    id,
    el,
    label,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $label
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$label*/
    64) {
      $: $$invalidate(2, builder = $label);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    label,
    $$restProps,
    id,
    $label,
    $$scope,
    slots,
    span_binding
  ];
}
var Date_range_field_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance92, create_fragment92, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_field_label",
      options,
      id: create_fragment92.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_field_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_field_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_field_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_field_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_field_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_field_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_field_label_default = Date_range_field_label;

// node_modules/bits-ui/dist/bits/date-range-field/components/date-range-field-segment.svelte
var file85 = "node_modules/bits-ui/dist/bits/date-range-field/components/date-range-field-segment.svelte";
var get_default_slot_changes_172 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_172 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes90 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context90 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block75(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context_172
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file85, 32, 1, 725);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[14](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes_172
            ),
            get_default_slot_context_172
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[14](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block75.name,
    type: "else",
    source: "(32:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block83(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context90
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes90
            ),
            get_default_slot_context90
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block83.name,
    type: "if",
    source: "(30:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment93(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block83, create_else_block75];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment93.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance93($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "part", "type", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $endSegment;
  let $startSegment;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_field_segment", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { part } = $$props;
  let { type } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { startSegment, endSegment }, ids, getAttrs: getAttrs2 } = getCtx13();
  validate_store(startSegment, "startSegment");
  component_subscribe($$self, startSegment, (value) => $$invalidate(11, $startSegment = value));
  validate_store(endSegment, "endSegment");
  component_subscribe($$self, endSegment, (value) => $$invalidate(10, $endSegment = value));
  const attrs = getAttrs2("segment");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (part === void 0 && !("part" in $$props || $$self.$$.bound[$$self.$$.props["part"]])) {
      console.warn("<Date_range_field_segment> was created without expected prop 'part'");
    }
    if (type === void 0 && !("type" in $$props || $$self.$$.bound[$$self.$$.props["type"]])) {
      console.warn("<Date_range_field_segment> was created without expected prop 'type'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(7, id = $$new_props.id);
    if ("part" in $$new_props) $$invalidate(8, part = $$new_props.part);
    if ("type" in $$new_props) $$invalidate(9, type = $$new_props.type);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(12, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx13,
    createDispatcher,
    asChild,
    id,
    part,
    type,
    el,
    startSegment,
    endSegment,
    ids,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $endSegment,
    $startSegment
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(7, id = $$new_props.id);
    if ("part" in $$props) $$invalidate(8, part = $$new_props.part);
    if ("type" in $$props) $$invalidate(9, type = $$new_props.type);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id, part, type*/
    896) {
      $: if (id && part !== "literal") {
        if (type === "start") {
          ids.start[part].set(id);
        } else {
          ids.end[part].set(id);
        }
      }
    }
    if ($$self.$$.dirty & /*type, $startSegment, part, $endSegment*/
    3840) {
      $: $$invalidate(2, builder = type === "start" ? $startSegment(part) : $endSegment(part));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    startSegment,
    endSegment,
    dispatch,
    $$restProps,
    id,
    part,
    type,
    $endSegment,
    $startSegment,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_field_segment = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance93, create_fragment93, safe_not_equal, {
      asChild: 1,
      id: 7,
      part: 8,
      type: 9,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_field_segment",
      options,
      id: create_fragment93.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get part() {
    throw new Error("<Date_range_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set part(value) {
    throw new Error("<Date_range_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get type() {
    throw new Error("<Date_range_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set type(value) {
    throw new Error("<Date_range_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_field_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_field_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_field_segment_default = Date_range_field_segment;

// node_modules/bits-ui/dist/bits/date-range-picker/index.js
var date_range_picker_exports = {};
__export(date_range_picker_exports, {
  Arrow: () => date_range_picker_arrow_default,
  Calendar: () => date_range_picker_calendar_default,
  Cell: () => date_range_picker_cell_default,
  Close: () => date_range_picker_close_default,
  Content: () => date_range_picker_content_default,
  Day: () => date_range_picker_day_default,
  Field: () => date_range_picker_field_default,
  Grid: () => date_range_picker_grid_default,
  GridBody: () => date_range_picker_grid_body_default,
  GridHead: () => date_range_picker_grid_head_default,
  GridRow: () => date_range_picker_grid_row_default,
  HeadCell: () => date_range_picker_head_cell_default,
  Header: () => date_range_picker_header_default,
  Heading: () => date_range_picker_heading_default,
  Input: () => date_range_picker_input_default,
  Label: () => date_range_picker_label_default,
  NextButton: () => date_range_picker_next_button_default,
  PrevButton: () => date_range_picker_prev_button_default,
  Root: () => date_range_picker_default,
  Segment: () => date_range_picker_segment_default,
  Trigger: () => date_range_picker_trigger_default
});

// node_modules/bits-ui/dist/bits/date-range-picker/ctx.js
function getDateRangePickerData() {
  const NAME = "date-range-picker";
  return {
    NAME
  };
}
function setCtx15(props) {
  const { NAME } = getDateRangePickerData();
  const { NAME: CALENDAR_NAME, PARTS: CALENDAR_PARTS } = getCalendarData();
  const getCalendarAttrs = createBitAttrs(CALENDAR_NAME, CALENDAR_PARTS);
  const { NAME: FIELD_NAME, PARTS: FIELD_PARTS } = getDateFieldData();
  const getFieldAttrs = createBitAttrs(FIELD_NAME, FIELD_PARTS);
  const { NAME: POPOVER_NAME, PARTS: POPOVER_PARTS } = getPopoverData();
  const getPopoverAttrs = createBitAttrs(POPOVER_NAME, POPOVER_PARTS);
  const dateRangePicker = {
    ...createDateRangePicker({ ...removeUndefined2(props), forceVisible: true }),
    getCalendarAttrs,
    getFieldAttrs,
    getPopoverAttrs
  };
  const updateOption = getOptionUpdater(dateRangePicker.options);
  setContext(NAME, { ...dateRangePicker, updateOption });
  return {
    ...dateRangePicker,
    updateOption
  };
}
function getCtx14() {
  const { NAME } = getDateRangePickerData();
  return getContext(NAME);
}
function updatePositioning7(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "center"
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx14();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-arrow.svelte
var file86 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-arrow.svelte";
var get_default_slot_changes91 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context91 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block76(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file86, 22, 1, 427);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block76.name,
    type: "else",
    source: "(22:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block84(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context91
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes91
            ),
            get_default_slot_context91
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block84.name,
    type: "if",
    source: "(20:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment94(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block84, create_else_block76];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment94.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance94($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "size"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_arrow", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { size: size3 = 8 } = $$props;
  const { elements: { arrow: arrow3 }, updateOption, getPopoverAttrs } = getCtx14();
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getPopoverAttrs("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx14,
    melt,
    asChild,
    el,
    size: size3,
    arrow: arrow3,
    updateOption,
    getPopoverAttrs,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*size*/
    32) {
      $: updateOption("arrowSize", size3);
    }
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_picker_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance94, create_fragment94, safe_not_equal, { asChild: 1, el: 0, size: 5 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_arrow",
      options,
      id: create_fragment94.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get size() {
    throw new Error("<Date_range_picker_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Date_range_picker_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_arrow_default = Date_range_picker_arrow;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-cell.svelte
var file87 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-cell.svelte";
var get_default_slot_changes_173 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context_173 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes92 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context92 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block77(ctx) {
  let td;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_173
  );
  let td_levels = [
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[2]
  ];
  let td_data = {};
  for (let i = 0; i < td_levels.length; i += 1) {
    td_data = assign(td_data, td_levels[i]);
  }
  const block = {
    c: function create() {
      td = element("td");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      td = claim_element(nodes, "TD", {});
      var td_nodes = children(td);
      if (default_slot) default_slot.l(td_nodes);
      td_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(td, td_data);
      add_location(td, file87, 20, 1, 460);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, td, anchor);
      if (default_slot) {
        default_slot.m(td, null);
      }
      ctx[11](td);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_173
            ),
            get_default_slot_context_173
          );
        }
      }
      set_attributes(td, td_data = get_spread_update(td_levels, [
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        dirty & /*attrs*/
        4 && /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(td);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block77.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block85(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context92
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes92
            ),
            get_default_slot_context92
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block85.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment95(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block85, create_else_block77];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment95.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance95($$self, $$props, $$invalidate) {
  let attrs;
  const omit_props_names = ["date", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateDisabled;
  let $isDateUnavailable;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_cell", slots, ["default"]);
  let { date } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { helpers: { isDateDisabled, isDateUnavailable }, getCalendarAttrs } = getCtx14();
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(7, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(8, $isDateUnavailable = value));
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Date_range_picker_cell> was created without expected prop 'date'");
    }
  });
  function td_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx14,
    date,
    asChild,
    el,
    isDateDisabled,
    isDateUnavailable,
    getCalendarAttrs,
    attrs,
    $isDateDisabled,
    $isDateUnavailable
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(2, attrs = $$new_props.attrs);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$isDateDisabled, date, $isDateUnavailable*/
    448) {
      $: $$invalidate(2, attrs = {
        ...getCalendarAttrs("cell"),
        "aria-disabled": $isDateDisabled(date) || $isDateUnavailable(date),
        "data-disabled": $isDateDisabled(date) ? "" : void 0,
        role: "gridcell"
      });
    }
  };
  return [
    el,
    asChild,
    attrs,
    isDateDisabled,
    isDateUnavailable,
    $$restProps,
    date,
    $isDateDisabled,
    $isDateUnavailable,
    $$scope,
    slots,
    td_binding
  ];
}
var Date_range_picker_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance95, create_fragment95, safe_not_equal, { date: 6, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_cell",
      options,
      id: create_fragment95.name
    });
  }
  get date() {
    throw new Error("<Date_range_picker_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Date_range_picker_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Date_range_picker_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_cell_default = Date_range_picker_cell;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-day.svelte
var file88 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-day.svelte";
var get_default_slot_changes_174 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  32,
  unavailable: dirty & /*unavailable*/
  16
});
var get_default_slot_context_174 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[5]
  ),
  unavailable: (
    /*unavailable*/
    ctx[4]
  )
});
var get_default_slot_changes93 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  32,
  unavailable: dirty & /*unavailable*/
  16
});
var get_default_slot_context93 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[5]
  ),
  unavailable: (
    /*unavailable*/
    ctx[4]
  )
});
function create_else_block78(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_174
  );
  const default_slot_or_fallback = default_slot || fallback_block6(ctx);
  let div_levels = [
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[9]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file88, 25, 1, 557);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[16](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[3].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable*/
        16440)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes_174
            ),
            get_default_slot_context_174
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*date*/
        2)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        512 && /*$$restProps*/
        ctx2[9]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[16](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block78.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block86(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context93
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable*/
        16440)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes93
            ),
            get_default_slot_context93
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block86.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block6(ctx) {
  let t_value = (
    /*date*/
    ctx[1].day + ""
  );
  let t;
  const block = {
    c: function create() {
      t = text(t_value);
    },
    l: function claim(nodes) {
      t = claim_text(nodes, t_value);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*date*/
      2 && t_value !== (t_value = /*date*/
      ctx2[1].day + "")) set_data_dev(t, t_value);
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block6.name,
    type: "fallback",
    source: "(27:43)     ",
    ctx
  });
  return block;
}
function create_fragment96(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block86, create_else_block78];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment96.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance96($$self, $$props, $$invalidate) {
  let builder;
  let disabled;
  let unavailable;
  const omit_props_names = ["date", "month", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateUnavailable;
  let $isDateDisabled;
  let $cell;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_day", slots, ["default"]);
  let { date } = $$props;
  let { month } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { cell }, helpers: { isDateDisabled, isDateUnavailable }, getCalendarAttrs } = getCtx14();
  validate_store(cell, "cell");
  component_subscribe($$self, cell, (value) => $$invalidate(13, $cell = value));
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(12, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(11, $isDateUnavailable = value));
  const attrs = getCalendarAttrs("day");
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Date_range_picker_day> was created without expected prop 'date'");
    }
    if (month === void 0 && !("month" in $$props || $$self.$$.bound[$$self.$$.props["month"]])) {
      console.warn("<Date_range_picker_day> was created without expected prop 'month'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(9, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$new_props) $$invalidate(10, month = $$new_props.month);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(14, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    date,
    month,
    asChild,
    el,
    cell,
    isDateDisabled,
    isDateUnavailable,
    getCalendarAttrs,
    attrs,
    unavailable,
    disabled,
    builder,
    $isDateUnavailable,
    $isDateDisabled,
    $cell
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$props) $$invalidate(10, month = $$new_props.month);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("unavailable" in $$props) $$invalidate(4, unavailable = $$new_props.unavailable);
    if ("disabled" in $$props) $$invalidate(5, disabled = $$new_props.disabled);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$cell, date, month*/
    9218) {
      $: $$invalidate(3, builder = $cell(date, month));
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$isDateDisabled, date*/
    4098) {
      $: $$invalidate(5, disabled = $isDateDisabled(date));
    }
    if ($$self.$$.dirty & /*$isDateUnavailable, date*/
    2050) {
      $: $$invalidate(4, unavailable = $isDateUnavailable(date));
    }
  };
  return [
    el,
    date,
    asChild,
    builder,
    unavailable,
    disabled,
    cell,
    isDateDisabled,
    isDateUnavailable,
    $$restProps,
    month,
    $isDateUnavailable,
    $isDateDisabled,
    $cell,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_picker_day = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance96, create_fragment96, safe_not_equal, { date: 1, month: 10, asChild: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_day",
      options,
      id: create_fragment96.name
    });
  }
  get date() {
    throw new Error("<Date_range_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Date_range_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get month() {
    throw new Error("<Date_range_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set month(value) {
    throw new Error("<Date_range_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Date_range_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_day_default = Date_range_picker_day;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-heading.svelte
var file89 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-heading.svelte";
var get_default_slot_changes_175 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context_175 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
var get_default_slot_changes94 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context94 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
function create_else_block79(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_175
  );
  const default_slot_or_fallback = default_slot || fallback_block7(ctx);
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file89, 19, 1, 417);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_175
            ),
            get_default_slot_context_175
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*$headingValue*/
        8)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block79.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block87(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context94
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes94
            ),
            get_default_slot_context94
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block87.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block7(ctx) {
  let t;
  const block = {
    c: function create() {
      t = text(
        /*$headingValue*/
        ctx[3]
      );
    },
    l: function claim(nodes) {
      t = claim_text(
        nodes,
        /*$headingValue*/
        ctx[3]
      );
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*$headingValue*/
      8) set_data_dev(
        t,
        /*$headingValue*/
        ctx2[3]
      );
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block7.name,
    type: "fallback",
    source: "(21:47)     ",
    ctx
  });
  return block;
}
function create_fragment97(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block87, create_else_block79];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment97.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance97($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $heading;
  let $headingValue;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_heading", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { heading }, states: { headingValue }, getCalendarAttrs } = getCtx14();
  validate_store(heading, "heading");
  component_subscribe($$self, heading, (value) => $$invalidate(7, $heading = value));
  validate_store(headingValue, "headingValue");
  component_subscribe($$self, headingValue, (value) => $$invalidate(3, $headingValue = value));
  const attrs = getCalendarAttrs("heading");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    el,
    heading,
    headingValue,
    getCalendarAttrs,
    attrs,
    builder,
    $heading,
    $headingValue
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$heading*/
    128) {
      $: $$invalidate(2, builder = $heading);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $headingValue,
    heading,
    headingValue,
    $$restProps,
    $heading,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_picker_heading = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance97, create_fragment97, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_heading",
      options,
      id: create_fragment97.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_heading_default = Date_range_picker_heading;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-next-button.svelte
var file90 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-next-button.svelte";
var get_default_slot_changes_176 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_176 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes95 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context95 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block80(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_176
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[4]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file90, 18, 1, 370);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[8](button);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(button));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_176
            ),
            get_default_slot_context_176
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block80.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block88(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context95
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes95
            ),
            get_default_slot_context95
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block88.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment98(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block88, create_else_block80];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment98.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance98($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $nextButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_next_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { nextButton }, getCalendarAttrs } = getCtx14();
  validate_store(nextButton, "nextButton");
  component_subscribe($$self, nextButton, (value) => $$invalidate(5, $nextButton = value));
  const attrs = getCalendarAttrs("next-button");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    el,
    nextButton,
    getCalendarAttrs,
    attrs,
    builder,
    $nextButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$nextButton*/
    32) {
      $: $$invalidate(2, builder = $nextButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    nextButton,
    $$restProps,
    $nextButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_range_picker_next_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance98, create_fragment98, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_next_button",
      options,
      id: create_fragment98.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_next_button_default = Date_range_picker_next_button;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-prev-button.svelte
var file91 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-prev-button.svelte";
var get_default_slot_changes_177 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_177 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes96 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context96 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block81(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_177
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[4]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file91, 18, 1, 370);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[8](button);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(button));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_177
            ),
            get_default_slot_context_177
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block81.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block89(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context96
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes96
            ),
            get_default_slot_context96
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block89.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment99(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block89, create_else_block81];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment99.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance99($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $prevButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_prev_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { prevButton }, getCalendarAttrs } = getCtx14();
  validate_store(prevButton, "prevButton");
  component_subscribe($$self, prevButton, (value) => $$invalidate(5, $prevButton = value));
  const attrs = getCalendarAttrs("prev-button");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    el,
    prevButton,
    getCalendarAttrs,
    attrs,
    builder,
    $prevButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$prevButton*/
    32) {
      $: $$invalidate(2, builder = $prevButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    prevButton,
    $$restProps,
    $prevButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_range_picker_prev_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance99, create_fragment99, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_prev_button",
      options,
      id: create_fragment99.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_prev_button_default = Date_range_picker_prev_button;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-calendar.svelte
var file92 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-calendar.svelte";
var get_default_slot_changes_178 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  months: dirty & /*months*/
  8,
  weekdays: dirty & /*$weekdays*/
  16
});
var get_default_slot_context_178 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  months: (
    /*months*/
    ctx[3]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[4]
  )
});
var get_default_slot_changes97 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  months: dirty & /*months*/
  8,
  weekdays: dirty & /*$weekdays*/
  16
});
var get_default_slot_context97 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  months: (
    /*months*/
    ctx[3]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[4]
  )
});
function create_else_block82(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context_178
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[8]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file92, 28, 1, 574);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[14](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, months, $weekdays*/
        4124)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes_178
            ),
            get_default_slot_context_178
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        256 && /*$$restProps*/
        ctx2[8]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[14](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block82.name,
    type: "else",
    source: "(28:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block90(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context97
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, months, $weekdays*/
        4124)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes97
            ),
            get_default_slot_context97
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block90.name,
    type: "if",
    source: "(26:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment100(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block90, create_else_block82];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment100.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance100($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $localMonths;
  let $calendar;
  let $weekdays;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_calendar", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { calendar }, states: { months: localMonths, weekdays }, ids, getCalendarAttrs } = getCtx14();
  validate_store(calendar, "calendar");
  component_subscribe($$self, calendar, (value) => $$invalidate(11, $calendar = value));
  validate_store(localMonths, "localMonths");
  component_subscribe($$self, localMonths, (value) => $$invalidate(10, $localMonths = value));
  validate_store(weekdays, "weekdays");
  component_subscribe($$self, weekdays, (value) => $$invalidate(4, $weekdays = value));
  const attrs = getCalendarAttrs("root");
  let months = $localMonths;
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(8, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(9, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(12, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    id,
    el,
    calendar,
    localMonths,
    weekdays,
    ids,
    getCalendarAttrs,
    attrs,
    months,
    builder,
    $localMonths,
    $calendar,
    $weekdays
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(9, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("months" in $$props) $$invalidate(3, months = $$new_props.months);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    512) {
      $: if (id) {
        ids.calendar.calendar.set(id);
      }
    }
    if ($$self.$$.dirty & /*$calendar*/
    2048) {
      $: $$invalidate(2, builder = $calendar);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$localMonths*/
    1024) {
      $: $$invalidate(3, months = $localMonths);
    }
  };
  return [
    el,
    asChild,
    builder,
    months,
    $weekdays,
    calendar,
    localMonths,
    weekdays,
    $$restProps,
    id,
    $localMonths,
    $calendar,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_picker_calendar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance100, create_fragment100, safe_not_equal, { asChild: 1, id: 9, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_calendar",
      options,
      id: create_fragment100.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_picker_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_picker_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_calendar_default = Date_range_picker_calendar;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-close.svelte
var file93 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-close.svelte";
var get_default_slot_changes_179 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_179 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes98 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context98 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block83(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_179
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file93, 20, 1, 453);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_179
            ),
            get_default_slot_context_179
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block83.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block91(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context98
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes98
            ),
            get_default_slot_context98
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block91.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment101(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block91, create_else_block83];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment101.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance101($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $close;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_close", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { close }, getPopoverAttrs } = getCtx14();
  validate_store(close, "close");
  component_subscribe($$self, close, (value) => $$invalidate(6, $close = value));
  const dispatch = createDispatcher();
  const attrs = getPopoverAttrs("close");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    createDispatcher,
    asChild,
    el,
    close,
    getPopoverAttrs,
    dispatch,
    attrs,
    builder,
    $close
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$close*/
    64) {
      $: $$invalidate(2, builder = $close);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    close,
    dispatch,
    $$restProps,
    $close,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_range_picker_close = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance101, create_fragment101, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_close",
      options,
      id: create_fragment101.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_close_default = Date_range_picker_close;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-content.svelte
var file94 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-content.svelte";
var get_default_slot_changes_58 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_58 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_48 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_48 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_38 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_38 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_28 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_28 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_180 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_180 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes99 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context99 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_59(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_58
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file94, 78, 1, 2025);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[26],
              dirty,
              get_default_slot_changes_58
            ),
            get_default_slot_context_58
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_59.name,
    type: "if",
    source: "(78:16) ",
    ctx
  });
  return block;
}
function create_if_block_49(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_48
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file94, 74, 1, 1868);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[31](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_48
            ),
            get_default_slot_context_48
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[31](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_49.name,
    type: "if",
    source: "(74:33) ",
    ctx
  });
  return block;
}
function create_if_block_39(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_38
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file94, 70, 1, 1697);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[30](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_38
            ),
            get_default_slot_context_38
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[30](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_39.name,
    type: "if",
    source: "(70:32) ",
    ctx
  });
  return block;
}
function create_if_block_29(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_28
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file94, 60, 1, 1475);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_28
            ),
            get_default_slot_context_28
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_29.name,
    type: "if",
    source: "(60:49) ",
    ctx
  });
  return block;
}
function create_if_block_112(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_180
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file94, 56, 1, 1284);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[28](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_180
            ),
            get_default_slot_context_180
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[28](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_112.name,
    type: "if",
    source: "(56:30) ",
    ctx
  });
  return block;
}
function create_if_block92(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context99
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[26],
              dirty,
              get_default_slot_changes99
            ),
            get_default_slot_context99
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block92.name,
    type: "if",
    source: "(54:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment102(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block92,
    create_if_block_112,
    create_if_block_29,
    create_if_block_39,
    create_if_block_49,
    create_if_block_59
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment102.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance102($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "bottom" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = false } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, ids, getPopoverAttrs } = getCtx14();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(25, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getPopoverAttrs("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(13, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(14, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(15, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(16, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(17, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(18, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(19, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(20, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(21, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(22, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(23, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(24, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(26, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    updatePositioning: updatePositioning7,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    content,
    open,
    ids,
    getPopoverAttrs,
    attrs,
    builder,
    $content,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(13, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(14, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(15, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(16, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(17, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(18, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(19, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(20, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(21, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(22, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(23, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(24, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    8192) {
      $: if (id) {
        ids.popover.content.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$content*/
    33554432) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    33538048) {
      $: updatePositioning7({
        side,
        align,
        sideOffset,
        alignOffset,
        collisionPadding,
        avoidCollisions,
        collisionBoundary,
        sameWidth,
        fitViewport,
        strategy,
        overlap
      });
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $content,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Date_range_picker_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance102,
      create_fragment102,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 13,
        side: 14,
        align: 15,
        sideOffset: 16,
        alignOffset: 17,
        collisionPadding: 18,
        avoidCollisions: 19,
        collisionBoundary: 20,
        sameWidth: 21,
        fitViewport: 22,
        strategy: 23,
        overlap: 24,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_content",
      options,
      id: create_fragment102.name
    });
  }
  get transition() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_content_default = Date_range_picker_content;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-field.svelte
var get_default_slot_changes100 = (dirty) => ({ isInvalid: dirty & /*$localIsInvalid*/
1 });
var get_default_slot_context100 = (ctx) => ({ isInvalid: (
  /*$localIsInvalid*/
  ctx[0]
) });
function create_fragment103(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context100
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $localIsInvalid*/
        32769)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes100
            ),
            get_default_slot_context100
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment103.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance103($$self, $$props, $$invalidate) {
  let $localIsInvalid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_field", slots, ["default"]);
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { granularity = void 0 } = $$props;
  let { hideTimeZone = void 0 } = $$props;
  let { hourCycle = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  const { states: { value: localValue, placeholder: localPlaceholder, isInvalid: localIsInvalid }, updateOption } = setCtx15({
    defaultValue: value,
    defaultPlaceholder: placeholder,
    disabled,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    isDateUnavailable,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(2, value = next2);
      }
      return next2;
    },
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(3, placeholder = next2);
      }
      return next2;
    }
  });
  validate_store(localIsInvalid, "localIsInvalid");
  component_subscribe($$self, localIsInvalid, (value2) => $$invalidate(0, $localIsInvalid = value2));
  const writable_props = [
    "value",
    "onValueChange",
    "placeholder",
    "onPlaceholderChange",
    "disabled",
    "isDateUnavailable",
    "granularity",
    "hideTimeZone",
    "hourCycle",
    "locale",
    "maxValue",
    "minValue",
    "readonly"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Date_range_picker_field> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("value" in $$props2) $$invalidate(2, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(4, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(3, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(5, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(6, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(7, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(8, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(9, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(10, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(11, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(12, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(13, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(14, readonly2 = $$props2.readonly);
    if ("$$scope" in $$props2) $$invalidate(15, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    setCtx: setCtx15,
    value,
    onValueChange,
    placeholder,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    localValue,
    localPlaceholder,
    localIsInvalid,
    updateOption,
    $localIsInvalid
  });
  $$self.$inject_state = ($$props2) => {
    if ("value" in $$props2) $$invalidate(2, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(4, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(3, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(5, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(6, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(7, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(8, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(9, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(10, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(11, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(12, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(13, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(14, readonly2 = $$props2.readonly);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    4) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*placeholder*/
    8) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty & /*disabled*/
    64) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*isDateUnavailable*/
    128) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty & /*granularity*/
    256) {
      $: updateOption("granularity", granularity);
    }
    if ($$self.$$.dirty & /*hideTimeZone*/
    512) {
      $: updateOption("hideTimeZone", hideTimeZone);
    }
    if ($$self.$$.dirty & /*hourCycle*/
    1024) {
      $: updateOption("hourCycle", hourCycle);
    }
    if ($$self.$$.dirty & /*locale*/
    2048) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty & /*maxValue*/
    4096) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty & /*minValue*/
    8192) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty & /*readonly*/
    16384) {
      $: updateOption("readonly", readonly2);
    }
  };
  return [
    $localIsInvalid,
    localIsInvalid,
    value,
    placeholder,
    onValueChange,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly2,
    $$scope,
    slots
  ];
}
var Date_range_picker_field = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance103, create_fragment103, safe_not_equal, {
      value: 2,
      onValueChange: 4,
      placeholder: 3,
      onPlaceholderChange: 5,
      disabled: 6,
      isDateUnavailable: 7,
      granularity: 8,
      hideTimeZone: 9,
      hourCycle: 10,
      locale: 11,
      maxValue: 12,
      minValue: 13,
      readonly: 14
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_field",
      options,
      id: create_fragment103.name
    });
  }
  get value() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get placeholder() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get granularity() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set granularity(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hideTimeZone() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hideTimeZone(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hourCycle() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hourCycle(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Date_range_picker_field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Date_range_picker_field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_field_default = Date_range_picker_field;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-input.svelte
var file95 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-input.svelte";
var get_default_slot_changes_181 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  segments: dirty & /*$segmentContents*/
  8
});
var get_default_slot_context_181 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  segments: (
    /*$segmentContents*/
    ctx[3]
  )
});
var get_default_slot_changes101 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  segments: dirty & /*$segmentContents*/
  8
});
var get_default_slot_context101 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  segments: (
    /*$segmentContents*/
    ctx[3]
  )
});
function create_else_block84(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_181
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file95, 25, 1, 497);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $segmentContents*/
        524)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_181
            ),
            get_default_slot_context_181
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block84.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block93(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context101
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $segmentContents*/
        524)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes101
            ),
            get_default_slot_context101
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block93.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment104(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block93, create_else_block84];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment104.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance104($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $field;
  let $segmentContents;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { field }, states: { segmentContents }, ids, getFieldAttrs } = getCtx14();
  validate_store(field, "field");
  component_subscribe($$self, field, (value) => $$invalidate(8, $field = value));
  validate_store(segmentContents, "segmentContents");
  component_subscribe($$self, segmentContents, (value) => $$invalidate(3, $segmentContents = value));
  const attrs = getFieldAttrs("input");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    id,
    el,
    field,
    segmentContents,
    ids,
    getFieldAttrs,
    attrs,
    builder,
    $field,
    $segmentContents
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    128) {
      $: if (id) {
        ids.rangeField.field.field.set(id);
      }
    }
    if ($$self.$$.dirty & /*$field*/
    256) {
      $: $$invalidate(2, builder = $field);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $segmentContents,
    field,
    segmentContents,
    $$restProps,
    id,
    $field,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_picker_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance104, create_fragment104, safe_not_equal, { asChild: 1, id: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_input",
      options,
      id: create_fragment104.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_picker_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_picker_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_input_default = Date_range_picker_input;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-label.svelte
var file96 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-label.svelte";
var get_default_slot_changes_182 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_182 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes102 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context102 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block85(ctx) {
  let span;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_182
  );
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      var span_nodes = children(span);
      if (default_slot) default_slot.l(span_nodes);
      span_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file96, 23, 1, 429);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      if (default_slot) {
        default_slot.m(span, null);
      }
      ctx[9](span);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_182
            ),
            get_default_slot_context_182
          );
        }
      }
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block85.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block94(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context102
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes102
            ),
            get_default_slot_context102
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block94.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment105(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block94, create_else_block85];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment105.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance105($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $label;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { label }, ids, getFieldAttrs } = getCtx14();
  validate_store(label, "label");
  component_subscribe($$self, label, (value) => $$invalidate(6, $label = value));
  if (id) {
    ids.rangeField.field.label.set(id);
  }
  const attrs = getFieldAttrs("label");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    id,
    el,
    label,
    ids,
    getFieldAttrs,
    attrs,
    builder,
    $label
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$label*/
    64) {
      $: $$invalidate(2, builder = $label);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    label,
    $$restProps,
    id,
    $label,
    $$scope,
    slots,
    span_binding
  ];
}
var Date_range_picker_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance105, create_fragment105, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_label",
      options,
      id: create_fragment105.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_picker_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_picker_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_label_default = Date_range_picker_label;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-segment.svelte
var file97 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-segment.svelte";
var get_default_slot_changes_183 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_183 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes103 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context103 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block86(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[12].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[11],
    get_default_slot_context_183
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file97, 30, 1, 656);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[13](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        2052)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[11],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[11]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[11],
              dirty,
              get_default_slot_changes_183
            ),
            get_default_slot_context_183
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[13](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block86.name,
    type: "else",
    source: "(30:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block95(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[12].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[11],
    get_default_slot_context103
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        2052)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[11],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[11]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[11],
              dirty,
              get_default_slot_changes103
            ),
            get_default_slot_context103
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block95.name,
    type: "if",
    source: "(28:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment106(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block95, create_else_block86];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment106.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance106($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "part", "type", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $endSegment;
  let $startSegment;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_segment", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { part } = $$props;
  let { type } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { startSegment, endSegment }, ids, getFieldAttrs } = getCtx14();
  validate_store(startSegment, "startSegment");
  component_subscribe($$self, startSegment, (value) => $$invalidate(10, $startSegment = value));
  validate_store(endSegment, "endSegment");
  component_subscribe($$self, endSegment, (value) => $$invalidate(9, $endSegment = value));
  const attrs = getFieldAttrs("segment");
  $$self.$$.on_mount.push(function() {
    if (part === void 0 && !("part" in $$props || $$self.$$.bound[$$self.$$.props["part"]])) {
      console.warn("<Date_range_picker_segment> was created without expected prop 'part'");
    }
    if (type === void 0 && !("type" in $$props || $$self.$$.bound[$$self.$$.props["type"]])) {
      console.warn("<Date_range_picker_segment> was created without expected prop 'type'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("part" in $$new_props) $$invalidate(7, part = $$new_props.part);
    if ("type" in $$new_props) $$invalidate(8, type = $$new_props.type);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(11, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    id,
    part,
    type,
    el,
    startSegment,
    endSegment,
    ids,
    getFieldAttrs,
    attrs,
    builder,
    $endSegment,
    $startSegment
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("part" in $$props) $$invalidate(7, part = $$new_props.part);
    if ("type" in $$props) $$invalidate(8, type = $$new_props.type);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id, part, type*/
    448) {
      $: if (id && part !== "literal") {
        if (type === "start") {
          ids.rangeField.start[part].set(id);
        } else {
          ids.rangeField.end[part].set(id);
        }
      }
    }
    if ($$self.$$.dirty & /*type, $startSegment, part, $endSegment*/
    1920) {
      $: $$invalidate(2, builder = type === "start" ? $startSegment(part) : $endSegment(part));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    startSegment,
    endSegment,
    $$restProps,
    id,
    part,
    type,
    $endSegment,
    $startSegment,
    $$scope,
    slots,
    div_binding
  ];
}
var Date_range_picker_segment = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance106, create_fragment106, safe_not_equal, {
      asChild: 1,
      id: 6,
      part: 7,
      type: 8,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_segment",
      options,
      id: create_fragment106.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get part() {
    throw new Error("<Date_range_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set part(value) {
    throw new Error("<Date_range_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get type() {
    throw new Error("<Date_range_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set type(value) {
    throw new Error("<Date_range_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_segment>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_segment>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_segment_default = Date_range_picker_segment;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-trigger.svelte
var file98 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-trigger.svelte";
var get_default_slot_changes_184 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_184 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes104 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context104 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block87(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_184
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file98, 26, 1, 542);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[10](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_184
            ),
            get_default_slot_context_184
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block87.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block96(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context104
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes104
            ),
            get_default_slot_context104
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block96.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment107(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block96, create_else_block87];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment107.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance107($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getPopoverAttrs } = getCtx14();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(7, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getPopoverAttrs("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    ids,
    getPopoverAttrs,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.popover.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    128) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Date_range_picker_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance107, create_fragment107, safe_not_equal, { asChild: 1, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_trigger",
      options,
      id: create_fragment107.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Date_range_picker_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Date_range_picker_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_trigger_default = Date_range_picker_trigger;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker.svelte
var get_default_slot_changes105 = (dirty) => ({
  ids: dirty[0] & /*$idValues*/
  2,
  isInvalid: dirty[0] & /*$localIsInvalid*/
  4,
  startValue: dirty[0] & /*$localStartValue*/
  1,
  endValue: dirty[0] & /*$endValue*/
  8
});
var get_default_slot_context105 = (ctx) => ({
  ids: (
    /*$idValues*/
    ctx[1]
  ),
  isInvalid: (
    /*$localIsInvalid*/
    ctx[2]
  ),
  startValue: (
    /*$localStartValue*/
    ctx[0]
  ),
  endValue: (
    /*$endValue*/
    ctx[3]
  )
});
function create_fragment108(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[34].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[33],
    get_default_slot_context105
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$idValues, $localIsInvalid, $localStartValue, $endValue*/
        15 | dirty[1] & /*$$scope*/
        4)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[33],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[33]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[33],
              dirty,
              get_default_slot_changes105
            ),
            get_default_slot_context105
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment108.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance108($$self, $$props, $$invalidate) {
  let $localStartValue;
  let $idValues;
  let $localIsInvalid;
  let $endValue;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker", slots, ["default"]);
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { granularity = void 0 } = $$props;
  let { hideTimeZone = void 0 } = $$props;
  let { hourCycle = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  let { validationId = void 0 } = $$props;
  let { descriptionId = void 0 } = $$props;
  let { preventDeselect = void 0 } = $$props;
  let { pagedNavigation = void 0 } = $$props;
  let { weekStartsOn = void 0 } = $$props;
  let { isDateDisabled = void 0 } = $$props;
  let { fixedWeeks = void 0 } = $$props;
  let { calendarLabel = void 0 } = $$props;
  let { weekdayFormat = void 0 } = $$props;
  let { startValue = void 0 } = $$props;
  let { numberOfMonths = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { value: localValue, placeholder: localPlaceholder, isInvalid: localIsInvalid, startValue: localStartValue, endValue }, updateOption, ids } = setCtx15({
    defaultValue: value,
    defaultPlaceholder: placeholder,
    preventDeselect,
    pagedNavigation,
    weekStartsOn,
    isDateDisabled,
    fixedWeeks,
    calendarLabel,
    disabled,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    weekdayFormat,
    numberOfMonths,
    isDateUnavailable,
    onOutsideClick,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(8, value = next2);
      }
      return next2;
    },
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(9, placeholder = next2);
      }
      return next2;
    }
  });
  validate_store(localIsInvalid, "localIsInvalid");
  component_subscribe($$self, localIsInvalid, (value2) => $$invalidate(2, $localIsInvalid = value2));
  validate_store(localStartValue, "localStartValue");
  component_subscribe($$self, localStartValue, (value2) => $$invalidate(0, $localStartValue = value2));
  validate_store(endValue, "endValue");
  component_subscribe($$self, endValue, (value2) => $$invalidate(3, $endValue = value2));
  const startFieldIds = derived(
    [
      ids.rangeField.start.day,
      ids.rangeField.start.dayPeriod,
      ids.rangeField.start.field,
      ids.rangeField.start.hour,
      ids.rangeField.start.minute,
      ids.rangeField.start.month,
      ids.rangeField.start.second,
      ids.rangeField.start.year,
      ids.rangeField.start.timeZoneName
    ],
    ([
      $dayId,
      $dayPeriodId,
      $hourId,
      $minuteId,
      $monthId,
      $secondId,
      $yearId,
      $timeZoneNameId
    ]) => ({
      day: $dayId,
      dayPeriod: $dayPeriodId,
      hour: $hourId,
      minute: $minuteId,
      month: $monthId,
      second: $secondId,
      year: $yearId,
      timeZoneName: $timeZoneNameId
    })
  );
  const endFieldIds = derived(
    [
      ids.rangeField.end.day,
      ids.rangeField.end.dayPeriod,
      ids.rangeField.end.field,
      ids.rangeField.end.hour,
      ids.rangeField.end.minute,
      ids.rangeField.end.month,
      ids.rangeField.end.second,
      ids.rangeField.end.year,
      ids.rangeField.end.timeZoneName
    ],
    ([
      $dayId,
      $dayPeriodId,
      $hourId,
      $minuteId,
      $monthId,
      $secondId,
      $yearId,
      $timeZoneNameId
    ]) => ({
      day: $dayId,
      dayPeriod: $dayPeriodId,
      hour: $hourId,
      minute: $minuteId,
      month: $monthId,
      second: $secondId,
      year: $yearId,
      timeZoneName: $timeZoneNameId
    })
  );
  const idValues = derived(
    [
      ids.rangeField.field.field,
      ids.rangeField.field.description,
      ids.rangeField.field.label,
      ids.rangeField.field.validation,
      ids.calendar.calendar,
      ids.popover.content,
      ids.popover.trigger,
      startFieldIds,
      endFieldIds
    ],
    ([
      $fieldId,
      $descriptionId,
      $labelId,
      $validationId,
      $calendarId,
      $contentId,
      $triggerId,
      $startFieldIds,
      $endFieldIds
    ]) => ({
      field: $fieldId,
      description: $descriptionId,
      label: $labelId,
      validation: $validationId,
      calendar: $calendarId,
      content: $contentId,
      trigger: $triggerId,
      startField: $startFieldIds,
      endField: $endFieldIds
    })
  );
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value2) => $$invalidate(1, $idValues = value2));
  const writable_props = [
    "value",
    "onValueChange",
    "placeholder",
    "onPlaceholderChange",
    "disabled",
    "isDateUnavailable",
    "granularity",
    "hideTimeZone",
    "hourCycle",
    "locale",
    "maxValue",
    "minValue",
    "readonly",
    "validationId",
    "descriptionId",
    "preventDeselect",
    "pagedNavigation",
    "weekStartsOn",
    "isDateDisabled",
    "fixedWeeks",
    "calendarLabel",
    "weekdayFormat",
    "startValue",
    "numberOfMonths",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Date_range_picker> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("value" in $$props2) $$invalidate(8, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(11, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(9, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(12, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(13, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(14, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(15, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(16, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(17, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(18, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(19, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(20, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(21, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(22, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(23, descriptionId = $$props2.descriptionId);
    if ("preventDeselect" in $$props2) $$invalidate(24, preventDeselect = $$props2.preventDeselect);
    if ("pagedNavigation" in $$props2) $$invalidate(25, pagedNavigation = $$props2.pagedNavigation);
    if ("weekStartsOn" in $$props2) $$invalidate(26, weekStartsOn = $$props2.weekStartsOn);
    if ("isDateDisabled" in $$props2) $$invalidate(27, isDateDisabled = $$props2.isDateDisabled);
    if ("fixedWeeks" in $$props2) $$invalidate(28, fixedWeeks = $$props2.fixedWeeks);
    if ("calendarLabel" in $$props2) $$invalidate(29, calendarLabel = $$props2.calendarLabel);
    if ("weekdayFormat" in $$props2) $$invalidate(30, weekdayFormat = $$props2.weekdayFormat);
    if ("startValue" in $$props2) $$invalidate(10, startValue = $$props2.startValue);
    if ("numberOfMonths" in $$props2) $$invalidate(31, numberOfMonths = $$props2.numberOfMonths);
    if ("onOutsideClick" in $$props2) $$invalidate(32, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(33, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx15,
    value,
    onValueChange,
    placeholder,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly: readonly2,
    validationId,
    descriptionId,
    preventDeselect,
    pagedNavigation,
    weekStartsOn,
    isDateDisabled,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    startValue,
    numberOfMonths,
    onOutsideClick,
    localValue,
    localPlaceholder,
    localIsInvalid,
    localStartValue,
    endValue,
    updateOption,
    ids,
    startFieldIds,
    endFieldIds,
    idValues,
    $localStartValue,
    $idValues,
    $localIsInvalid,
    $endValue
  });
  $$self.$inject_state = ($$props2) => {
    if ("value" in $$props2) $$invalidate(8, value = $$props2.value);
    if ("onValueChange" in $$props2) $$invalidate(11, onValueChange = $$props2.onValueChange);
    if ("placeholder" in $$props2) $$invalidate(9, placeholder = $$props2.placeholder);
    if ("onPlaceholderChange" in $$props2) $$invalidate(12, onPlaceholderChange = $$props2.onPlaceholderChange);
    if ("disabled" in $$props2) $$invalidate(13, disabled = $$props2.disabled);
    if ("isDateUnavailable" in $$props2) $$invalidate(14, isDateUnavailable = $$props2.isDateUnavailable);
    if ("granularity" in $$props2) $$invalidate(15, granularity = $$props2.granularity);
    if ("hideTimeZone" in $$props2) $$invalidate(16, hideTimeZone = $$props2.hideTimeZone);
    if ("hourCycle" in $$props2) $$invalidate(17, hourCycle = $$props2.hourCycle);
    if ("locale" in $$props2) $$invalidate(18, locale = $$props2.locale);
    if ("maxValue" in $$props2) $$invalidate(19, maxValue = $$props2.maxValue);
    if ("minValue" in $$props2) $$invalidate(20, minValue = $$props2.minValue);
    if ("readonly" in $$props2) $$invalidate(21, readonly2 = $$props2.readonly);
    if ("validationId" in $$props2) $$invalidate(22, validationId = $$props2.validationId);
    if ("descriptionId" in $$props2) $$invalidate(23, descriptionId = $$props2.descriptionId);
    if ("preventDeselect" in $$props2) $$invalidate(24, preventDeselect = $$props2.preventDeselect);
    if ("pagedNavigation" in $$props2) $$invalidate(25, pagedNavigation = $$props2.pagedNavigation);
    if ("weekStartsOn" in $$props2) $$invalidate(26, weekStartsOn = $$props2.weekStartsOn);
    if ("isDateDisabled" in $$props2) $$invalidate(27, isDateDisabled = $$props2.isDateDisabled);
    if ("fixedWeeks" in $$props2) $$invalidate(28, fixedWeeks = $$props2.fixedWeeks);
    if ("calendarLabel" in $$props2) $$invalidate(29, calendarLabel = $$props2.calendarLabel);
    if ("weekdayFormat" in $$props2) $$invalidate(30, weekdayFormat = $$props2.weekdayFormat);
    if ("startValue" in $$props2) $$invalidate(10, startValue = $$props2.startValue);
    if ("numberOfMonths" in $$props2) $$invalidate(31, numberOfMonths = $$props2.numberOfMonths);
    if ("onOutsideClick" in $$props2) $$invalidate(32, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*validationId*/
    4194304) {
      $: if (validationId) {
        ids.rangeField.field.validation.set(validationId);
      }
    }
    if ($$self.$$.dirty[0] & /*descriptionId*/
    8388608) {
      $: if (descriptionId) {
        ids.rangeField.field.description.set(descriptionId);
      }
    }
    if ($$self.$$.dirty[0] & /*$localStartValue*/
    1) {
      $: $$invalidate(10, startValue = $localStartValue);
    }
    if ($$self.$$.dirty[0] & /*value*/
    256) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty[0] & /*placeholder*/
    512) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty[0] & /*disabled*/
    8192) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty[0] & /*isDateUnavailable*/
    16384) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty[0] & /*granularity*/
    32768) {
      $: updateOption("granularity", granularity);
    }
    if ($$self.$$.dirty[0] & /*hideTimeZone*/
    65536) {
      $: updateOption("hideTimeZone", hideTimeZone);
    }
    if ($$self.$$.dirty[0] & /*hourCycle*/
    131072) {
      $: updateOption("hourCycle", hourCycle);
    }
    if ($$self.$$.dirty[0] & /*locale*/
    262144) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty[0] & /*maxValue*/
    524288) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty[0] & /*minValue*/
    1048576) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty[0] & /*readonly*/
    2097152) {
      $: updateOption("readonly", readonly2);
    }
    if ($$self.$$.dirty[0] & /*fixedWeeks*/
    268435456) {
      $: updateOption("fixedWeeks", fixedWeeks);
    }
    if ($$self.$$.dirty[0] & /*preventDeselect*/
    16777216) {
      $: updateOption("preventDeselect", preventDeselect);
    }
    if ($$self.$$.dirty[0] & /*pagedNavigation*/
    33554432) {
      $: updateOption("pagedNavigation", pagedNavigation);
    }
    if ($$self.$$.dirty[0] & /*weekStartsOn*/
    67108864) {
      $: updateOption("weekStartsOn", weekStartsOn);
    }
    if ($$self.$$.dirty[0] & /*isDateDisabled*/
    134217728) {
      $: updateOption("isDateDisabled", isDateDisabled);
    }
    if ($$self.$$.dirty[0] & /*calendarLabel*/
    536870912) {
      $: updateOption("calendarLabel", calendarLabel);
    }
    if ($$self.$$.dirty[0] & /*weekdayFormat*/
    1073741824) {
      $: updateOption("weekdayFormat", weekdayFormat);
    }
    if ($$self.$$.dirty[1] & /*numberOfMonths*/
    1) {
      $: updateOption("numberOfMonths", numberOfMonths);
    }
    if ($$self.$$.dirty[1] & /*onOutsideClick*/
    2) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $localStartValue,
    $idValues,
    $localIsInvalid,
    $endValue,
    localIsInvalid,
    localStartValue,
    endValue,
    idValues,
    value,
    placeholder,
    startValue,
    onValueChange,
    onPlaceholderChange,
    disabled,
    isDateUnavailable,
    granularity,
    hideTimeZone,
    hourCycle,
    locale,
    maxValue,
    minValue,
    readonly2,
    validationId,
    descriptionId,
    preventDeselect,
    pagedNavigation,
    weekStartsOn,
    isDateDisabled,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    numberOfMonths,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Date_range_picker = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance108,
      create_fragment108,
      safe_not_equal,
      {
        value: 8,
        onValueChange: 11,
        placeholder: 9,
        onPlaceholderChange: 12,
        disabled: 13,
        isDateUnavailable: 14,
        granularity: 15,
        hideTimeZone: 16,
        hourCycle: 17,
        locale: 18,
        maxValue: 19,
        minValue: 20,
        readonly: 21,
        validationId: 22,
        descriptionId: 23,
        preventDeselect: 24,
        pagedNavigation: 25,
        weekStartsOn: 26,
        isDateDisabled: 27,
        fixedWeeks: 28,
        calendarLabel: 29,
        weekdayFormat: 30,
        startValue: 10,
        numberOfMonths: 31,
        onOutsideClick: 32
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker",
      options,
      id: create_fragment108.name
    });
  }
  get value() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get placeholder() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get granularity() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set granularity(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hideTimeZone() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hideTimeZone(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hourCycle() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hourCycle(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get validationId() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set validationId(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get descriptionId() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set descriptionId(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventDeselect() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventDeselect(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get pagedNavigation() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set pagedNavigation(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekStartsOn() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekStartsOn(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateDisabled() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateDisabled(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fixedWeeks() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fixedWeeks(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get calendarLabel() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set calendarLabel(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekdayFormat() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekdayFormat(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get startValue() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set startValue(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get numberOfMonths() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set numberOfMonths(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Date_range_picker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Date_range_picker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_default = Date_range_picker;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid.svelte
var file99 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid.svelte";
var get_default_slot_changes_185 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_185 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes106 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context106 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block88(ctx) {
  let table;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_185
  );
  let table_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let table_data = {};
  for (let i = 0; i < table_levels.length; i += 1) {
    table_data = assign(table_data, table_levels[i]);
  }
  const block = {
    c: function create() {
      table = element("table");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      table = claim_element(nodes, "TABLE", {});
      var table_nodes = children(table);
      if (default_slot) default_slot.l(table_nodes);
      table_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(table, table_data);
      add_location(table, file99, 18, 1, 351);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, table, anchor);
      if (default_slot) {
        default_slot.m(table, null);
      }
      ctx[8](table);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(table));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_185
            ),
            get_default_slot_context_185
          );
        }
      }
      set_attributes(table, table_data = get_spread_update(table_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(table);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block88.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block97(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context106
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes106
            ),
            get_default_slot_context106
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block97.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment109(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block97, create_else_block88];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment109.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance109($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $grid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_grid", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { grid }, getCalendarAttrs } = getCtx14();
  validate_store(grid, "grid");
  component_subscribe($$self, grid, (value) => $$invalidate(5, $grid = value));
  const attrs = getCalendarAttrs("grid");
  function table_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx14,
    asChild,
    el,
    grid,
    getCalendarAttrs,
    attrs,
    builder,
    $grid
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$grid*/
    32) {
      $: $$invalidate(2, builder = $grid);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, grid, $$restProps, $grid, $$scope, slots, table_binding];
}
var Date_range_picker_grid = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance109, create_fragment109, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_grid",
      options,
      id: create_fragment109.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_grid_default = Date_range_picker_grid;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid-body.svelte
var file100 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid-body.svelte";
var get_default_slot_changes107 = (dirty) => ({});
var get_default_slot_context107 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block89(ctx) {
  let tbody;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    null
  );
  let tbody_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tbody_data = {};
  for (let i = 0; i < tbody_levels.length; i += 1) {
    tbody_data = assign(tbody_data, tbody_levels[i]);
  }
  const block = {
    c: function create() {
      tbody = element("tbody");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tbody = claim_element(nodes, "TBODY", {});
      var tbody_nodes = children(tbody);
      if (default_slot) default_slot.l(tbody_nodes);
      tbody_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tbody, tbody_data);
      add_location(tbody, file100, 10, 1, 232);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tbody, anchor);
      if (default_slot) {
        default_slot.m(tbody, null);
      }
      ctx[6](tbody);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(tbody, tbody_data = get_spread_update(tbody_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tbody);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block89.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block98(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context107
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes107
            ),
            get_default_slot_context107
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block98.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment110(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block98, create_else_block89];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment110.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance110($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_grid_body", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx14();
  const attrs = getCalendarAttrs("grid-body");
  function tbody_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx14,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tbody_binding];
}
var Date_range_picker_grid_body = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance110, create_fragment110, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_grid_body",
      options,
      id: create_fragment110.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_grid_body_default = Date_range_picker_grid_body;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid-head.svelte
var file101 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid-head.svelte";
var get_default_slot_changes108 = (dirty) => ({});
var get_default_slot_context108 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block90(ctx) {
  let thead;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    null
  );
  let thead_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let thead_data = {};
  for (let i = 0; i < thead_levels.length; i += 1) {
    thead_data = assign(thead_data, thead_levels[i]);
  }
  const block = {
    c: function create() {
      thead = element("thead");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      thead = claim_element(nodes, "THEAD", {});
      var thead_nodes = children(thead);
      if (default_slot) default_slot.l(thead_nodes);
      thead_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(thead, thead_data);
      add_location(thead, file101, 10, 1, 260);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, thead, anchor);
      if (default_slot) {
        default_slot.m(thead, null);
      }
      ctx[6](thead);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(thead, thead_data = get_spread_update(thead_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(thead);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block90.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block99(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context108
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes108
            ),
            get_default_slot_context108
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block99.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment111(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block99, create_else_block90];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment111.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance111($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_grid_head", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx14();
  const attrs = {
    ...getCalendarAttrs("grid-head"),
    "aria-hidden": true
  };
  function thead_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx14,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, thead_binding];
}
var Date_range_picker_grid_head = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance111, create_fragment111, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_grid_head",
      options,
      id: create_fragment111.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_grid_head_default = Date_range_picker_grid_head;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid-row.svelte
var file102 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-grid-row.svelte";
var get_default_slot_changes_186 = (dirty) => ({});
var get_default_slot_context_186 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes109 = (dirty) => ({});
var get_default_slot_context109 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block91(ctx) {
  let tr;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_186
  );
  let tr_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tr_data = {};
  for (let i = 0; i < tr_levels.length; i += 1) {
    tr_data = assign(tr_data, tr_levels[i]);
  }
  const block = {
    c: function create() {
      tr = element("tr");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tr = claim_element(nodes, "TR", {});
      var tr_nodes = children(tr);
      if (default_slot) default_slot.l(tr_nodes);
      tr_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tr, tr_data);
      add_location(tr, file102, 10, 1, 231);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tr, anchor);
      if (default_slot) {
        default_slot.m(tr, null);
      }
      ctx[6](tr);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_186
            ),
            get_default_slot_context_186
          );
        }
      }
      set_attributes(tr, tr_data = get_spread_update(tr_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tr);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block91.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block100(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context109
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes109
            ),
            get_default_slot_context109
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block100.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment112(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block100, create_else_block91];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment112.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance112($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_grid_row", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx14();
  const attrs = getCalendarAttrs("grid-row");
  function tr_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx14,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tr_binding];
}
var Date_range_picker_grid_row = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance112, create_fragment112, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_grid_row",
      options,
      id: create_fragment112.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_grid_row_default = Date_range_picker_grid_row;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-head-cell.svelte
var file103 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-head-cell.svelte";
var get_default_slot_changes110 = (dirty) => ({});
var get_default_slot_context110 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block92(ctx) {
  let th;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    null
  );
  let th_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let th_data = {};
  for (let i = 0; i < th_levels.length; i += 1) {
    th_data = assign(th_data, th_levels[i]);
  }
  const block = {
    c: function create() {
      th = element("th");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      th = claim_element(nodes, "TH", {});
      var th_nodes = children(th);
      if (default_slot) default_slot.l(th_nodes);
      th_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(th, th_data);
      add_location(th, file103, 10, 1, 232);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, th, anchor);
      if (default_slot) {
        default_slot.m(th, null);
      }
      ctx[6](th);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(th, th_data = get_spread_update(th_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(th);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block92.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block101(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context110
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes110
            ),
            get_default_slot_context110
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block101.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment113(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block101, create_else_block92];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment113.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance113($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_head_cell", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx14();
  const attrs = getCalendarAttrs("head-cell");
  function th_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx14,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, th_binding];
}
var Date_range_picker_head_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance113, create_fragment113, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_head_cell",
      options,
      id: create_fragment113.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_head_cell_default = Date_range_picker_head_cell;

// node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-header.svelte
var file104 = "node_modules/bits-ui/dist/bits/date-range-picker/components/date-range-picker-header.svelte";
var get_default_slot_changes_187 = (dirty) => ({});
var get_default_slot_context_187 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes111 = (dirty) => ({});
var get_default_slot_context111 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block93(ctx) {
  let header;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_187
  );
  let header_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let header_data = {};
  for (let i = 0; i < header_levels.length; i += 1) {
    header_data = assign(header_data, header_levels[i]);
  }
  const block = {
    c: function create() {
      header = element("header");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      header = claim_element(nodes, "HEADER", {});
      var header_nodes = children(header);
      if (default_slot) default_slot.l(header_nodes);
      header_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(header, header_data);
      add_location(header, file104, 10, 1, 229);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, header, anchor);
      if (default_slot) {
        default_slot.m(header, null);
      }
      ctx[6](header);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_187
            ),
            get_default_slot_context_187
          );
        }
      }
      set_attributes(header, header_data = get_spread_update(header_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(header);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block93.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block102(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context111
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes111
            ),
            get_default_slot_context111
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block102.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment114(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block102, create_else_block93];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment114.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance114($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Date_range_picker_header", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getCalendarAttrs } = getCtx14();
  const attrs = getCalendarAttrs("header");
  function header_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx14,
    asChild,
    el,
    getCalendarAttrs,
    attrs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, header_binding];
}
var Date_range_picker_header = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance114, create_fragment114, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Date_range_picker_header",
      options,
      id: create_fragment114.name
    });
  }
  get asChild() {
    throw new Error("<Date_range_picker_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Date_range_picker_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Date_range_picker_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Date_range_picker_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var date_range_picker_header_default = Date_range_picker_header;

// node_modules/bits-ui/dist/bits/dialog/index.js
var dialog_exports = {};
__export(dialog_exports, {
  Close: () => dialog_close_default,
  Content: () => dialog_content_default,
  Description: () => dialog_description_default,
  Overlay: () => dialog_overlay_default,
  Portal: () => dialog_portal_default,
  Root: () => dialog_default,
  Title: () => dialog_title_default,
  Trigger: () => dialog_trigger_default
});

// node_modules/bits-ui/dist/bits/dialog/ctx.js
function getDialogData() {
  const NAME = "dialog";
  const PARTS = [
    "close",
    "content",
    "description",
    "overlay",
    "portal",
    "title",
    "trigger"
  ];
  return {
    NAME,
    PARTS
  };
}
function setCtx16(props) {
  const { NAME, PARTS } = getDialogData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const dialog = {
    ...createDialog({ ...removeUndefined2(props), role: "dialog", forceVisible: true }),
    getAttrs: getAttrs2
  };
  setContext(NAME, dialog);
  return {
    ...dialog,
    updateOption: getOptionUpdater(dialog.options)
  };
}
function getCtx15() {
  const { NAME } = getDialogData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/dialog/components/dialog.svelte
var get_default_slot_changes112 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context112 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment115(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[12].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[11],
    get_default_slot_context112
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        2049)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[11],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[11]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[11],
              dirty,
              get_default_slot_changes112
            ),
            get_default_slot_context112
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment115.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance115($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog", slots, ["default"]);
  let { preventScroll = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { closeOnOutsideClick = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { openFocus = void 0 } = $$props;
  let { closeFocus = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { open: localOpen }, updateOption, ids } = setCtx16({
    closeOnEscape,
    preventScroll,
    closeOnOutsideClick,
    portal,
    forceVisible: true,
    defaultOpen: open,
    openFocus,
    closeFocus,
    onOutsideClick,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.content, ids.description, ids.title], ([$contentId, $descriptionId, $titleId]) => ({
    content: $contentId,
    description: $descriptionId,
    title: $titleId
  }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "preventScroll",
    "closeOnEscape",
    "closeOnOutsideClick",
    "portal",
    "open",
    "onOpenChange",
    "openFocus",
    "closeFocus",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Dialog> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("preventScroll" in $$props2) $$invalidate(3, preventScroll = $$props2.preventScroll);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(5, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(6, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(7, onOpenChange = $$props2.onOpenChange);
    if ("openFocus" in $$props2) $$invalidate(8, openFocus = $$props2.openFocus);
    if ("closeFocus" in $$props2) $$invalidate(9, closeFocus = $$props2.closeFocus);
    if ("onOutsideClick" in $$props2) $$invalidate(10, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(11, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx16,
    preventScroll,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    open,
    onOpenChange,
    openFocus,
    closeFocus,
    onOutsideClick,
    localOpen,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("preventScroll" in $$props2) $$invalidate(3, preventScroll = $$props2.preventScroll);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(5, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(6, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(7, onOpenChange = $$props2.onOpenChange);
    if ("openFocus" in $$props2) $$invalidate(8, openFocus = $$props2.openFocus);
    if ("closeFocus" in $$props2) $$invalidate(9, closeFocus = $$props2.closeFocus);
    if ("onOutsideClick" in $$props2) $$invalidate(10, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    8) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    16) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    32) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*portal*/
    64) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*openFocus*/
    256) {
      $: updateOption("openFocus", openFocus);
    }
    if ($$self.$$.dirty & /*closeFocus*/
    512) {
      $: updateOption("closeFocus", closeFocus);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    1024) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    preventScroll,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    onOpenChange,
    openFocus,
    closeFocus,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Dialog = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance115, create_fragment115, safe_not_equal, {
      preventScroll: 3,
      closeOnEscape: 4,
      closeOnOutsideClick: 5,
      portal: 6,
      open: 2,
      onOpenChange: 7,
      openFocus: 8,
      closeFocus: 9,
      onOutsideClick: 10
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog",
      options,
      id: create_fragment115.name
    });
  }
  get preventScroll() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnOutsideClick() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get openFocus() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set openFocus(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeFocus() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeFocus(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Dialog>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Dialog>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_default = Dialog;

// node_modules/bits-ui/dist/bits/dialog/components/dialog-title.svelte
var file105 = "node_modules/bits-ui/dist/bits/dialog/components/dialog-title.svelte";
var get_default_slot_changes_188 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context_188 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
var get_default_slot_changes113 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context113 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
function create_else_block94(ctx) {
  let previous_tag = (
    /*level*/
    ctx[1]
  );
  let svelte_element_anchor;
  let current;
  validate_dynamic_element(
    /*level*/
    ctx[1]
  );
  validate_void_dynamic_element(
    /*level*/
    ctx[1]
  );
  let svelte_element = (
    /*level*/
    ctx[1] && create_dynamic_element4(ctx)
  );
  const block = {
    c: function create() {
      if (svelte_element) svelte_element.c();
      svelte_element_anchor = empty();
    },
    l: function claim(nodes) {
      if (svelte_element) svelte_element.l(nodes);
      svelte_element_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (svelte_element) svelte_element.m(target, anchor);
      insert_hydration_dev(target, svelte_element_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*level*/
        ctx2[1]
      ) {
        if (!previous_tag) {
          svelte_element = create_dynamic_element4(ctx2);
          previous_tag = /*level*/
          ctx2[1];
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else if (safe_not_equal(
          previous_tag,
          /*level*/
          ctx2[1]
        )) {
          svelte_element.d(1);
          validate_dynamic_element(
            /*level*/
            ctx2[1]
          );
          validate_void_dynamic_element(
            /*level*/
            ctx2[1]
          );
          svelte_element = create_dynamic_element4(ctx2);
          previous_tag = /*level*/
          ctx2[1];
          svelte_element.c();
          svelte_element.m(svelte_element_anchor.parentNode, svelte_element_anchor);
        } else {
          svelte_element.p(ctx2, dirty);
        }
      } else if (previous_tag) {
        svelte_element.d(1);
        svelte_element = null;
        previous_tag = /*level*/
        ctx2[1];
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(svelte_element, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(svelte_element, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element_anchor);
      }
      if (svelte_element) svelte_element.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block94.name,
    type: "else",
    source: "(25:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block103(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context113
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes113
            ),
            get_default_slot_context113
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block103.name,
    type: "if",
    source: "(23:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_dynamic_element4(ctx) {
  let svelte_element;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_188
  );
  let svelte_element_levels = [
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[5]
  ];
  let svelte_element_data = {};
  for (let i = 0; i < svelte_element_levels.length; i += 1) {
    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
  }
  const block = {
    c: function create() {
      svelte_element = element(
        /*level*/
        ctx[1]
      );
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      svelte_element = claim_element(
        nodes,
        /*level*/
        (ctx[1] || "null").toUpperCase(),
        {}
      );
      var svelte_element_nodes = children(svelte_element);
      if (default_slot) default_slot.l(svelte_element_nodes);
      svelte_element_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_dynamic_element_data(
        /*level*/
        ctx[1]
      )(svelte_element, svelte_element_data);
      add_location(svelte_element, file105, 25, 1, 436);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, svelte_element, anchor);
      if (default_slot) {
        default_slot.m(svelte_element, null);
      }
      ctx[10](svelte_element);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[3].action(svelte_element));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_188
            ),
            get_default_slot_context_188
          );
        }
      }
      set_dynamic_element_data(
        /*level*/
        ctx2[1]
      )(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_dynamic_element4.name,
    type: "child_dynamic_element",
    source: "(26:1) <svelte:element this={level} bind:this={el} {...builder} use:builder.action {...$$restProps}>",
    ctx
  });
  return block;
}
function create_fragment116(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block103, create_else_block94];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment116.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance116($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["level", "asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $title;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog_title", slots, ["default"]);
  let { level = "h2" } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { title }, ids, getAttrs: getAttrs2 } = getCtx15();
  validate_store(title, "title");
  component_subscribe($$self, title, (value) => $$invalidate(7, $title = value));
  const attrs = getAttrs2("title");
  function svelte_element_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("level" in $$new_props) $$invalidate(1, level = $$new_props.level);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx15,
    level,
    asChild,
    id,
    el,
    title,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $title
  });
  $$self.$inject_state = ($$new_props) => {
    if ("level" in $$props) $$invalidate(1, level = $$new_props.level);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.title.set(id);
      }
    }
    if ($$self.$$.dirty & /*$title*/
    128) {
      $: $$invalidate(3, builder = $title);
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    level,
    asChild,
    builder,
    title,
    $$restProps,
    id,
    $title,
    $$scope,
    slots,
    svelte_element_binding
  ];
}
var Dialog_title = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance116, create_fragment116, safe_not_equal, { level: 1, asChild: 2, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog_title",
      options,
      id: create_fragment116.name
    });
  }
  get level() {
    throw new Error("<Dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set level(value) {
    throw new Error("<Dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Dialog_title>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Dialog_title>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_title_default = Dialog_title;

// node_modules/bits-ui/dist/bits/dialog/components/dialog-close.svelte
var file106 = "node_modules/bits-ui/dist/bits/dialog/components/dialog-close.svelte";
var get_default_slot_changes_189 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_189 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes114 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context114 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block95(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_189
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file106, 20, 1, 439);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_189
            ),
            get_default_slot_context_189
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block95.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block104(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context114
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes114
            ),
            get_default_slot_context114
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block104.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment117(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block104, create_else_block95];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment117.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance117($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $close;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog_close", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { close }, getAttrs: getAttrs2 } = getCtx15();
  validate_store(close, "close");
  component_subscribe($$self, close, (value) => $$invalidate(6, $close = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("close");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx15,
    createDispatcher,
    asChild,
    el,
    close,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $close
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$close*/
    64) {
      $: $$invalidate(2, builder = $close);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    close,
    dispatch,
    $$restProps,
    $close,
    $$scope,
    slots,
    button_binding
  ];
}
var Dialog_close = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance117, create_fragment117, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog_close",
      options,
      id: create_fragment117.name
    });
  }
  get asChild() {
    throw new Error("<Dialog_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Dialog_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Dialog_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Dialog_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_close_default = Dialog_close;

// node_modules/bits-ui/dist/bits/dialog/components/dialog-portal.svelte
var file107 = "node_modules/bits-ui/dist/bits/dialog/components/dialog-portal.svelte";
var get_default_slot_changes_190 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_190 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes115 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context115 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block96(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_190
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file107, 18, 1, 347);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_190
            ),
            get_default_slot_context_190
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block96.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block105(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context115
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes115
            ),
            get_default_slot_context115
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block105.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment118(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block105, create_else_block96];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment118.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance118($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $portalled;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog_portal", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { portalled }, getAttrs: getAttrs2 } = getCtx15();
  validate_store(portalled, "portalled");
  component_subscribe($$self, portalled, (value) => $$invalidate(5, $portalled = value));
  const attrs = getAttrs2("portal");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx15,
    asChild,
    el,
    portalled,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $portalled
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$portalled*/
    32) {
      $: $$invalidate(2, builder = $portalled);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    portalled,
    $$restProps,
    $portalled,
    $$scope,
    slots,
    div_binding
  ];
}
var Dialog_portal = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance118, create_fragment118, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog_portal",
      options,
      id: create_fragment118.name
    });
  }
  get asChild() {
    throw new Error("<Dialog_portal>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Dialog_portal>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Dialog_portal>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Dialog_portal>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_portal_default = Dialog_portal;

// node_modules/bits-ui/dist/bits/dialog/components/dialog-content.svelte
var file108 = "node_modules/bits-ui/dist/bits/dialog/components/dialog-content.svelte";
var get_default_slot_changes_59 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_59 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_49 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_49 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_39 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_39 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_29 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_29 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_191 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_191 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes116 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context116 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_510(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_59
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file108, 96, 1, 1906);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[56](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_4*/
            ctx[45],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_4*/
            ctx[46],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_4*/
            ctx[47],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_4*/
            ctx[48],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_4*/
            ctx[49],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_4*/
            ctx[50],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_4*/
            ctx[51],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes_59
            ),
            get_default_slot_context_59
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[56](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_510.name,
    type: "if",
    source: "(96:16) ",
    ctx
  });
  return block;
}
function create_if_block_410(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_49
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file108, 80, 1, 1628);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[55](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_3*/
            ctx[38],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_3*/
            ctx[39],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_3*/
            ctx[40],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_3*/
            ctx[41],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_3*/
            ctx[42],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_3*/
            ctx[43],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_3*/
            ctx[44],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_49
            ),
            get_default_slot_context_49
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[55](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_410.name,
    type: "if",
    source: "(80:33) ",
    ctx
  });
  return block;
}
function create_if_block_310(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_39
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file108, 64, 1, 1336);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[54](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_2*/
            ctx[31],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_2*/
            ctx[32],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_2*/
            ctx[33],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_2*/
            ctx[34],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_2*/
            ctx[35],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_2*/
            ctx[36],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_2*/
            ctx[37],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_39
            ),
            get_default_slot_context_39
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[54](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_310.name,
    type: "if",
    source: "(64:32) ",
    ctx
  });
  return block;
}
function create_if_block_210(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_29
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file108, 47, 1, 1003);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[53](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler_1*/
            ctx[24],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler_1*/
            ctx[25],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler_1*/
            ctx[26],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler_1*/
            ctx[27],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler_1*/
            ctx[28],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler_1*/
            ctx[29],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler_1*/
            ctx[30],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_29
            ),
            get_default_slot_context_29
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[53](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_210.name,
    type: "if",
    source: "(47:49) ",
    ctx
  });
  return block;
}
function create_if_block_113(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_191
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file108, 31, 1, 691);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[52](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "pointerdown",
            /*pointerdown_handler*/
            ctx[17],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointermove",
            /*pointermove_handler*/
            ctx[18],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerup",
            /*pointerup_handler*/
            ctx[19],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchend",
            /*touchend_handler*/
            ctx[20],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchstart",
            /*touchstart_handler*/
            ctx[21],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchcancel",
            /*touchcancel_handler*/
            ctx[22],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "touchmove",
            /*touchmove_handler*/
            ctx[23],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[15],
              dirty,
              get_default_slot_changes_191
            ),
            get_default_slot_context_191
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[52](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_113.name,
    type: "if",
    source: "(31:30) ",
    ctx
  });
  return block;
}
function create_if_block106(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context116
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        33024)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes116
            ),
            get_default_slot_context116
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block106.name,
    type: "if",
    source: "(29:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment119(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block106,
    create_if_block_113,
    create_if_block_210,
    create_if_block_310,
    create_if_block_410,
    create_if_block_510
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment119.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance119($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx15();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(14, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getAttrs2("content");
  function pointerdown_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function pointerdown_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function pointermove_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function pointerup_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchend_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchstart_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchcancel_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function touchmove_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(13, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(15, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx15,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    el,
    content,
    open,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $content,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(13, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    8192) {
      $: if (id) {
        ids.content.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$content*/
    16384) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    $$restProps,
    id,
    $content,
    $$scope,
    slots,
    pointerdown_handler,
    pointermove_handler,
    pointerup_handler,
    touchend_handler,
    touchstart_handler,
    touchcancel_handler,
    touchmove_handler,
    pointerdown_handler_1,
    pointermove_handler_1,
    pointerup_handler_1,
    touchend_handler_1,
    touchstart_handler_1,
    touchcancel_handler_1,
    touchmove_handler_1,
    pointerdown_handler_2,
    pointermove_handler_2,
    pointerup_handler_2,
    touchend_handler_2,
    touchstart_handler_2,
    touchcancel_handler_2,
    touchmove_handler_2,
    pointerdown_handler_3,
    pointermove_handler_3,
    pointerup_handler_3,
    touchend_handler_3,
    touchstart_handler_3,
    touchcancel_handler_3,
    touchmove_handler_3,
    pointerdown_handler_4,
    pointermove_handler_4,
    pointerup_handler_4,
    touchend_handler_4,
    touchstart_handler_4,
    touchcancel_handler_4,
    touchmove_handler_4,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Dialog_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance119,
      create_fragment119,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 13,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog_content",
      options,
      id: create_fragment119.name
    });
  }
  get transition() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Dialog_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Dialog_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_content_default = Dialog_content;

// node_modules/bits-ui/dist/bits/dialog/components/dialog-overlay.svelte
var file109 = "node_modules/bits-ui/dist/bits/dialog/components/dialog-overlay.svelte";
var get_default_slot_changes117 = (dirty) => ({ builder: dirty & /*builder*/
256 });
var get_default_slot_context117 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_511(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file109, 63, 1, 1627);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[25](div);
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "mouseup",
            /*mouseup_handler_4*/
            ctx[20],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[25](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_511.name,
    type: "if",
    source: "(62:16) ",
    ctx
  });
  return block;
}
function create_if_block_411(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file109, 54, 1, 1415);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[24](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "mouseup",
            /*mouseup_handler_3*/
            ctx[19],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[24](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_411.name,
    type: "if",
    source: "(53:33) ",
    ctx
  });
  return block;
}
function create_if_block_311(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file109, 45, 1, 1189);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[23](div);
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "mouseup",
            /*mouseup_handler_2*/
            ctx[18],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
    },
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[23](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_311.name,
    type: "if",
    source: "(44:32) ",
    ctx
  });
  return block;
}
function create_if_block_211(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file109, 35, 1, 922);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[22](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "mouseup",
            /*mouseup_handler_1*/
            ctx[17],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[22](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_211.name,
    type: "if",
    source: "(34:49) ",
    ctx
  });
  return block;
}
function create_if_block_114(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file109, 26, 1, 676);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[21](div);
      current = true;
      if (!mounted) {
        dispose = [
          listen_dev(
            div,
            "mouseup",
            /*mouseup_handler*/
            ctx[16],
            false,
            false,
            false,
            false
          ),
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div))
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[21](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_114.name,
    type: "if",
    source: "(25:30) ",
    ctx
  });
  return block;
}
function create_if_block107(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context117
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        16640)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes117
            ),
            get_default_slot_context117
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block107.name,
    type: "if",
    source: "(23:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment120(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block107,
    create_if_block_114,
    create_if_block_211,
    create_if_block_311,
    create_if_block_411,
    create_if_block_511
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, -1))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment120.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance120($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $overlay;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog_overlay", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { overlay }, states: { open }, getAttrs: getAttrs2 } = getCtx15();
  validate_store(overlay, "overlay");
  component_subscribe($$self, overlay, (value) => $$invalidate(13, $overlay = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getAttrs2("overlay");
  function mouseup_handler(event) {
    bubble.call(this, $$self, event);
  }
  function mouseup_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function mouseup_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function mouseup_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function mouseup_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(14, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx15,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    el,
    overlay,
    open,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $overlay,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$overlay*/
    8192) {
      $: $$invalidate(8, builder = $overlay);
    }
    if ($$self.$$.dirty & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    overlay,
    open,
    $$restProps,
    $overlay,
    $$scope,
    slots,
    mouseup_handler,
    mouseup_handler_1,
    mouseup_handler_2,
    mouseup_handler_3,
    mouseup_handler_4,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Dialog_overlay = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance120, create_fragment120, safe_not_equal, {
      transition: 1,
      transitionConfig: 2,
      inTransition: 3,
      inTransitionConfig: 4,
      outTransition: 5,
      outTransitionConfig: 6,
      asChild: 7,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog_overlay",
      options,
      id: create_fragment120.name
    });
  }
  get transition() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Dialog_overlay>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Dialog_overlay>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_overlay_default = Dialog_overlay;

// node_modules/bits-ui/dist/bits/dialog/components/dialog-trigger.svelte
var file110 = "node_modules/bits-ui/dist/bits/dialog/components/dialog-trigger.svelte";
var get_default_slot_changes_192 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_192 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes118 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context118 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block97(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_192
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file110, 20, 1, 445);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_192
            ),
            get_default_slot_context_192
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block97.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block108(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context118
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes118
            ),
            get_default_slot_context118
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block108.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment121(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block108, create_else_block97];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment121.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance121($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, getAttrs: getAttrs2 } = getCtx15();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(6, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx15,
    createDispatcher,
    asChild,
    el,
    trigger,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$trigger*/
    64) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Dialog_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance121, create_fragment121, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog_trigger",
      options,
      id: create_fragment121.name
    });
  }
  get asChild() {
    throw new Error("<Dialog_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Dialog_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Dialog_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Dialog_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_trigger_default = Dialog_trigger;

// node_modules/bits-ui/dist/bits/dialog/components/dialog-description.svelte
var file111 = "node_modules/bits-ui/dist/bits/dialog/components/dialog-description.svelte";
var get_default_slot_changes_193 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_193 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes119 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context119 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block98(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_193
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file111, 24, 1, 435);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[9](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_193
            ),
            get_default_slot_context_193
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block98.name,
    type: "else",
    source: "(24:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block109(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context119
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes119
            ),
            get_default_slot_context119
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block109.name,
    type: "if",
    source: "(22:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment122(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block109, create_else_block98];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment122.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance122($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $description;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Dialog_description", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { description }, ids, getAttrs: getAttrs2 } = getCtx15();
  validate_store(description, "description");
  component_subscribe($$self, description, (value) => $$invalidate(6, $description = value));
  const attrs = getAttrs2("description");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx15,
    asChild,
    id,
    el,
    description,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $description
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    32) {
      $: if (id) {
        ids.description.set(id);
      }
    }
    if ($$self.$$.dirty & /*$description*/
    64) {
      $: $$invalidate(2, builder = $description);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    description,
    $$restProps,
    id,
    $description,
    $$scope,
    slots,
    div_binding
  ];
}
var Dialog_description = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance122, create_fragment122, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Dialog_description",
      options,
      id: create_fragment122.name
    });
  }
  get asChild() {
    throw new Error("<Dialog_description>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Dialog_description>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Dialog_description>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Dialog_description>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Dialog_description>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Dialog_description>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var dialog_description_default = Dialog_description;

// node_modules/bits-ui/dist/bits/dropdown-menu/index.js
var dropdown_menu_exports = {};
__export(dropdown_menu_exports, {
  Arrow: () => menu_arrow_default,
  CheckboxIndicator: () => menu_checkbox_indicator_default,
  CheckboxItem: () => menu_checkbox_item_default,
  Content: () => menu_content_default,
  Group: () => menu_group_default,
  Item: () => menu_item_default,
  Label: () => menu_label_default,
  RadioGroup: () => menu_radio_group_default,
  RadioIndicator: () => menu_radio_indicator_default,
  RadioItem: () => menu_radio_item_default,
  Root: () => menu_default,
  Separator: () => menu_separator_default,
  Sub: () => menu_sub_default,
  SubContent: () => menu_sub_content_default,
  SubTrigger: () => menu_sub_trigger_default,
  Trigger: () => menu_trigger_default
});

// node_modules/bits-ui/dist/bits/menu/components/menu.svelte
var get_default_slot_changes120 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context120 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment123(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context120
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        32769)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes120
            ),
            get_default_slot_context120
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment123.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance123($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu", slots, ["default"]);
  let { closeOnOutsideClick = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { preventScroll = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { dir = void 0 } = $$props;
  let { typeahead = void 0 } = $$props;
  let { closeFocus = void 0 } = $$props;
  let { disableFocusFirstItem = void 0 } = $$props;
  let { closeOnItemClick = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { open: localOpen }, updateOption, ids } = setCtx10({
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    forceVisible: true,
    defaultOpen: open,
    preventScroll,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    closeOnItemClick,
    onOutsideClick,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.menu, ids.trigger], ([$menuId, $triggerId]) => ({ menu: $menuId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "closeOnOutsideClick",
    "closeOnEscape",
    "portal",
    "open",
    "onOpenChange",
    "preventScroll",
    "loop",
    "dir",
    "typeahead",
    "closeFocus",
    "disableFocusFirstItem",
    "closeOnItemClick",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Menu> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("closeOnOutsideClick" in $$props2) $$invalidate(3, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(5, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(6, onOpenChange = $$props2.onOpenChange);
    if ("preventScroll" in $$props2) $$invalidate(7, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(8, loop = $$props2.loop);
    if ("dir" in $$props2) $$invalidate(9, dir = $$props2.dir);
    if ("typeahead" in $$props2) $$invalidate(10, typeahead = $$props2.typeahead);
    if ("closeFocus" in $$props2) $$invalidate(11, closeFocus = $$props2.closeFocus);
    if ("disableFocusFirstItem" in $$props2) $$invalidate(12, disableFocusFirstItem = $$props2.disableFocusFirstItem);
    if ("closeOnItemClick" in $$props2) $$invalidate(13, closeOnItemClick = $$props2.closeOnItemClick);
    if ("onOutsideClick" in $$props2) $$invalidate(14, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(15, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    setCtx: setCtx10,
    derived,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    open,
    onOpenChange,
    preventScroll,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    closeOnItemClick,
    onOutsideClick,
    localOpen,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("closeOnOutsideClick" in $$props2) $$invalidate(3, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(5, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(6, onOpenChange = $$props2.onOpenChange);
    if ("preventScroll" in $$props2) $$invalidate(7, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(8, loop = $$props2.loop);
    if ("dir" in $$props2) $$invalidate(9, dir = $$props2.dir);
    if ("typeahead" in $$props2) $$invalidate(10, typeahead = $$props2.typeahead);
    if ("closeFocus" in $$props2) $$invalidate(11, closeFocus = $$props2.closeFocus);
    if ("disableFocusFirstItem" in $$props2) $$invalidate(12, disableFocusFirstItem = $$props2.disableFocusFirstItem);
    if ("closeOnItemClick" in $$props2) $$invalidate(13, closeOnItemClick = $$props2.closeOnItemClick);
    if ("onOutsideClick" in $$props2) $$invalidate(14, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    8) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    16) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*portal*/
    32) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    128) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*loop*/
    256) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*dir*/
    512) {
      $: updateOption("dir", dir);
    }
    if ($$self.$$.dirty & /*closeFocus*/
    2048) {
      $: updateOption("closeFocus", closeFocus);
    }
    if ($$self.$$.dirty & /*disableFocusFirstItem*/
    4096) {
      $: updateOption("disableFocusFirstItem", disableFocusFirstItem);
    }
    if ($$self.$$.dirty & /*typeahead*/
    1024) {
      $: updateOption("typeahead", typeahead);
    }
    if ($$self.$$.dirty & /*closeOnItemClick*/
    8192) {
      $: updateOption("closeOnItemClick", closeOnItemClick);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    16384) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    onOpenChange,
    preventScroll,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    closeOnItemClick,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Menu = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance123, create_fragment123, safe_not_equal, {
      closeOnOutsideClick: 3,
      closeOnEscape: 4,
      portal: 5,
      open: 2,
      onOpenChange: 6,
      preventScroll: 7,
      loop: 8,
      dir: 9,
      typeahead: 10,
      closeFocus: 11,
      disableFocusFirstItem: 12,
      closeOnItemClick: 13,
      onOutsideClick: 14
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu",
      options,
      id: create_fragment123.name
    });
  }
  get closeOnOutsideClick() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventScroll() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get dir() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set dir(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get typeahead() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set typeahead(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeFocus() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeFocus(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disableFocusFirstItem() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disableFocusFirstItem(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnItemClick() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnItemClick(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_default = Menu;

// node_modules/bits-ui/dist/bits/menu/components/menu-content.svelte
var file112 = "node_modules/bits-ui/dist/bits/menu/components/menu-content.svelte";
var get_default_slot_changes_510 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_510 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_410 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_410 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_310 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_310 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_210 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_210 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_194 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_194 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes121 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context121 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_512(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_510
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file112, 101, 1, 2274);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[33](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes_510
            ),
            get_default_slot_context_510
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[33](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_512.name,
    type: "if",
    source: "(101:16) ",
    ctx
  });
  return block;
}
function create_if_block_412(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_410
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file112, 91, 1, 2081);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_410
            ),
            get_default_slot_context_410
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_412.name,
    type: "if",
    source: "(91:33) ",
    ctx
  });
  return block;
}
function create_if_block_312(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_310
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file112, 81, 1, 1874);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[31](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_310
            ),
            get_default_slot_context_310
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[31](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_312.name,
    type: "if",
    source: "(81:32) ",
    ctx
  });
  return block;
}
function create_if_block_212(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_210
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file112, 70, 1, 1626);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[30](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_210
            ),
            get_default_slot_context_210
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[30](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_212.name,
    type: "if",
    source: "(70:49) ",
    ctx
  });
  return block;
}
function create_if_block_115(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_194
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file112, 60, 1, 1399);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_194
            ),
            get_default_slot_context_194
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_115.name,
    type: "if",
    source: "(60:30) ",
    ctx
  });
  return block;
}
function create_if_block110(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context121
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes121
            ),
            get_default_slot_context121
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block110.name,
    type: "if",
    source: "(58:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment124(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block110,
    create_if_block_115,
    create_if_block_212,
    create_if_block_312,
    create_if_block_412,
    create_if_block_512
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment124.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance124($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $open;
  let $menu;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "bottom" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = false } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { menu }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx9();
  validate_store(menu, "menu");
  component_subscribe($$self, menu, (value) => $$invalidate(26, $menu = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(27, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    melt,
    getCtx: getCtx9,
    updatePositioning: updatePositioning4,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    menu,
    open,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $open,
    $menu
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    16384) {
      $: if (id) {
        ids.menu.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$menu*/
    67108864) {
      $: $$invalidate(8, builder = $menu);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*$open, side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    67076608) {
      $: if ($open) {
        updatePositioning4({
          side,
          align,
          sideOffset,
          alignOffset,
          collisionPadding,
          avoidCollisions,
          collisionBoundary,
          sameWidth,
          fitViewport,
          strategy,
          overlap
        });
      }
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    menu,
    open,
    dispatch,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $menu,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Menu_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance124,
      create_fragment124,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 14,
        side: 15,
        align: 16,
        sideOffset: 17,
        alignOffset: 18,
        collisionPadding: 19,
        avoidCollisions: 20,
        collisionBoundary: 21,
        sameWidth: 22,
        fitViewport: 23,
        strategy: 24,
        overlap: 25,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_content",
      options,
      id: create_fragment124.name
    });
  }
  get transition() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_content_default = Menu_content;

// node_modules/bits-ui/dist/bits/menu/components/menu-trigger.svelte
var file113 = "node_modules/bits-ui/dist/bits/menu/components/menu-trigger.svelte";
var get_default_slot_changes_195 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_195 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes122 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context122 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block99(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_195
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file113, 26, 1, 520);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[10](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-pointerdown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_195
            ),
            get_default_slot_context_195
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block99.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block111(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context122
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes122
            ),
            get_default_slot_context122
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block111.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment125(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block111, create_else_block99];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment125.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance125($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menu_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getAttrs: getAttrs2 } = getCtx9();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(7, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx9,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    128) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Menu_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance125, create_fragment125, safe_not_equal, { asChild: 1, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menu_trigger",
      options,
      id: create_fragment125.name
    });
  }
  get asChild() {
    throw new Error("<Menu_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menu_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Menu_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Menu_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menu_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menu_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menu_trigger_default = Menu_trigger;

// node_modules/bits-ui/dist/bits/label/index.js
var label_exports = {};
__export(label_exports, {
  Root: () => label_default
});

// node_modules/bits-ui/dist/bits/label/ctx.js
function getLabelData() {
  const NAME = "label";
  const PARTS = ["root"];
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  return {
    NAME,
    getAttrs: getAttrs2
  };
}

// node_modules/bits-ui/dist/bits/label/components/label.svelte
var file114 = "node_modules/bits-ui/dist/bits/label/components/label.svelte";
var get_default_slot_changes_196 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_196 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes123 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context123 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block100(ctx) {
  let label;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_196
  );
  let label_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let label_data = {};
  for (let i = 0; i < label_levels.length; i += 1) {
    label_data = assign(label_data, label_levels[i]);
  }
  const block = {
    c: function create() {
      label = element("label");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      label = claim_element(nodes, "LABEL", {});
      var label_nodes = children(label);
      if (default_slot) default_slot.l(label_nodes);
      label_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(label, label_data);
      add_location(label, file114, 20, 1, 485);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, label, anchor);
      if (default_slot) {
        default_slot.m(label, null);
      }
      ctx[9](label);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(label)),
          listen_dev(
            label,
            "m-mousedown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_196
            ),
            get_default_slot_context_196
          );
        }
      }
      set_attributes(label, label_data = get_spread_update(label_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(label);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block100.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block112(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context123
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes123
            ),
            get_default_slot_context123
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block112.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment126(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block112, create_else_block100];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment126.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance126($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root } } = createLabel();
  validate_store(root, "root");
  component_subscribe($$self, root, (value) => $$invalidate(6, $root = value));
  const dispatch = createDispatcher();
  const { getAttrs: getAttrs2 } = getLabelData();
  const attrs = getAttrs2("root");
  function label_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    createLabel,
    getLabelData,
    createDispatcher,
    asChild,
    el,
    root,
    dispatch,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$root*/
    64) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    dispatch,
    $$restProps,
    $root,
    $$scope,
    slots,
    label_binding
  ];
}
var Label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance126, create_fragment126, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Label",
      options,
      id: create_fragment126.name
    });
  }
  get asChild() {
    throw new Error("<Label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var label_default = Label;

// node_modules/bits-ui/dist/bits/link-preview/index.js
var link_preview_exports = {};
__export(link_preview_exports, {
  Arrow: () => link_preview_arrow_default,
  Content: () => link_preview_content_default,
  Root: () => link_preview_default,
  Trigger: () => link_preview_trigger_default
});

// node_modules/bits-ui/dist/bits/link-preview/ctx.js
function getLinkPreviewData() {
  const NAME = "link-preview";
  const PARTS = ["arrow", "content", "trigger"];
  return {
    NAME,
    PARTS
  };
}
function setCtx17(props) {
  const { NAME, PARTS } = getLinkPreviewData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const linkPreview = {
    ...createLinkPreview({
      ...removeUndefined2(props),
      forceVisible: true
    }),
    getAttrs: getAttrs2
  };
  setContext(NAME, linkPreview);
  return {
    ...linkPreview,
    updateOption: getOptionUpdater(linkPreview.options)
  };
}
function getCtx16() {
  const { NAME } = getLinkPreviewData();
  return getContext(NAME);
}
function setArrow4(size3 = 8) {
  const linkPreview = getCtx16();
  linkPreview.options.arrowSize.set(size3);
  return linkPreview;
}
function updatePositioning8(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "center"
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx16();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/link-preview/components/link-preview.svelte
var get_default_slot_changes124 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context124 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment127(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context124
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        1025)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes124
            ),
            get_default_slot_context124
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment127.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance127($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Link_preview", slots, ["default"]);
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { openDelay = 700 } = $$props;
  let { closeDelay = 300 } = $$props;
  let { closeOnOutsideClick = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { open: localOpen }, updateOption, ids } = setCtx17({
    defaultOpen: open,
    openDelay,
    closeDelay,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    onOutsideClick,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.content, ids.trigger], ([$contentId, $triggerId]) => ({ content: $contentId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "open",
    "onOpenChange",
    "openDelay",
    "closeDelay",
    "closeOnOutsideClick",
    "closeOnEscape",
    "portal",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Link_preview> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(3, onOpenChange = $$props2.onOpenChange);
    if ("openDelay" in $$props2) $$invalidate(4, openDelay = $$props2.openDelay);
    if ("closeDelay" in $$props2) $$invalidate(5, closeDelay = $$props2.closeDelay);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(6, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(7, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(8, portal = $$props2.portal);
    if ("onOutsideClick" in $$props2) $$invalidate(9, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(10, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx17,
    open,
    onOpenChange,
    openDelay,
    closeDelay,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    onOutsideClick,
    localOpen,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(3, onOpenChange = $$props2.onOpenChange);
    if ("openDelay" in $$props2) $$invalidate(4, openDelay = $$props2.openDelay);
    if ("closeDelay" in $$props2) $$invalidate(5, closeDelay = $$props2.closeDelay);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(6, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(7, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(8, portal = $$props2.portal);
    if ("onOutsideClick" in $$props2) $$invalidate(9, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*openDelay*/
    16) {
      $: updateOption("openDelay", openDelay);
    }
    if ($$self.$$.dirty & /*closeDelay*/
    32) {
      $: updateOption("closeDelay", closeDelay);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    64) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    128) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*portal*/
    256) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    512) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    onOpenChange,
    openDelay,
    closeDelay,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Link_preview = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance127, create_fragment127, safe_not_equal, {
      open: 2,
      onOpenChange: 3,
      openDelay: 4,
      closeDelay: 5,
      closeOnOutsideClick: 6,
      closeOnEscape: 7,
      portal: 8,
      onOutsideClick: 9
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Link_preview",
      options,
      id: create_fragment127.name
    });
  }
  get open() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get openDelay() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set openDelay(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeDelay() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeDelay(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnOutsideClick() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Link_preview>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Link_preview>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var link_preview_default = Link_preview;

// node_modules/bits-ui/dist/bits/link-preview/components/link-preview-arrow.svelte
var file115 = "node_modules/bits-ui/dist/bits/link-preview/components/link-preview-arrow.svelte";
var get_default_slot_changes125 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context125 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block101(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file115, 19, 1, 367);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block101.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block113(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context125
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes125
            ),
            get_default_slot_context125
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block113.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment128(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block113, create_else_block101];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment128.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance128($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "size"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Link_preview_arrow", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { size: size3 = 8 } = $$props;
  const { elements: { arrow: arrow3 }, getAttrs: getAttrs2 } = setArrow4(size3);
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getAttrs2("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    setArrow: setArrow4,
    melt,
    asChild,
    el,
    size: size3,
    arrow: arrow3,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Link_preview_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance128, create_fragment128, safe_not_equal, { asChild: 1, el: 0, size: 5 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Link_preview_arrow",
      options,
      id: create_fragment128.name
    });
  }
  get asChild() {
    throw new Error("<Link_preview_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Link_preview_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Link_preview_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Link_preview_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get size() {
    throw new Error("<Link_preview_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Link_preview_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var link_preview_arrow_default = Link_preview_arrow;

// node_modules/bits-ui/dist/bits/link-preview/components/link-preview-content.svelte
var file116 = "node_modules/bits-ui/dist/bits/link-preview/components/link-preview-content.svelte";
var get_default_slot_changes_511 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_511 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_411 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_411 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_311 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_311 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_211 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_211 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_197 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_197 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes126 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context126 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_513(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_511
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file116, 113, 1, 2654);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[33](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes_511
            ),
            get_default_slot_context_511
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[33](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_513.name,
    type: "if",
    source: "(113:16) ",
    ctx
  });
  return block;
}
function create_if_block_413(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_411
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file116, 100, 1, 2368);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_411
            ),
            get_default_slot_context_411
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_413.name,
    type: "if",
    source: "(100:33) ",
    ctx
  });
  return block;
}
function create_if_block_313(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_311
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file116, 87, 1, 2068);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[31](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_311
            ),
            get_default_slot_context_311
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[31](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_313.name,
    type: "if",
    source: "(87:32) ",
    ctx
  });
  return block;
}
function create_if_block_213(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_211
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file116, 73, 1, 1727);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[30](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_211
            ),
            get_default_slot_context_211
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[30](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_213.name,
    type: "if",
    source: "(73:49) ",
    ctx
  });
  return block;
}
function create_if_block_116(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_197
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file116, 60, 1, 1407);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-focusout",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_197
            ),
            get_default_slot_context_197
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_116.name,
    type: "if",
    source: "(60:30) ",
    ctx
  });
  return block;
}
function create_if_block114(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context126
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes126
            ),
            get_default_slot_context126
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block114.name,
    type: "if",
    source: "(58:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment129(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block114,
    create_if_block_116,
    create_if_block_213,
    create_if_block_313,
    create_if_block_413,
    create_if_block_513
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment129.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance129($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $open;
  let $content;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Link_preview_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "bottom" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = false } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx16();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(26, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getAttrs2("content");
  const dispatch = createDispatcher();
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(27, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    createDispatcher,
    getCtx: getCtx16,
    updatePositioning: updatePositioning8,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    content,
    open,
    ids,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $open,
    $content
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    16384) {
      $: if (id) {
        ids.content.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$content*/
    67108864) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*$open, side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    67076608) {
      $: if ($open) {
        updatePositioning8({
          side,
          align,
          sideOffset,
          alignOffset,
          collisionPadding,
          avoidCollisions,
          collisionBoundary,
          sameWidth,
          fitViewport,
          strategy,
          overlap
        });
      }
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    dispatch,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $content,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Link_preview_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance129,
      create_fragment129,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 14,
        side: 15,
        align: 16,
        sideOffset: 17,
        alignOffset: 18,
        collisionPadding: 19,
        avoidCollisions: 20,
        collisionBoundary: 21,
        sameWidth: 22,
        fitViewport: 23,
        strategy: 24,
        overlap: 25,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Link_preview_content",
      options,
      id: create_fragment129.name
    });
  }
  get transition() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Link_preview_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Link_preview_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var link_preview_content_default = Link_preview_content;

// node_modules/bits-ui/dist/bits/link-preview/components/link-preview-trigger.svelte
var file117 = "node_modules/bits-ui/dist/bits/link-preview/components/link-preview-trigger.svelte";
var get_default_slot_changes_198 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_198 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes127 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context127 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block102(ctx) {
  let current;
  validate_dynamic_element("a");
  validate_void_dynamic_element("a");
  let svelte_element = create_dynamic_element5(ctx);
  const block = {
    c: function create() {
      if (svelte_element) svelte_element.c();
    },
    l: function claim(nodes) {
      if (svelte_element) svelte_element.l(nodes);
    },
    m: function mount(target, anchor) {
      if (svelte_element) svelte_element.m(target, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if ("a") {
        svelte_element.p(ctx2, dirty);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(svelte_element, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(svelte_element, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (svelte_element) svelte_element.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block102.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block115(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context127
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes127
            ),
            get_default_slot_context127
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block115.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_dynamic_element5(ctx) {
  let svelte_element;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_198
  );
  let svelte_element_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6],
    /*attrs*/
    ctx[5]
  ];
  let svelte_element_data = {};
  for (let i = 0; i < svelte_element_levels.length; i += 1) {
    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
  }
  const block = {
    c: function create() {
      svelte_element = element("a");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      svelte_element = claim_element(nodes, "A", {});
      var svelte_element_nodes = children(svelte_element);
      if (default_slot) default_slot.l(svelte_element_nodes);
      svelte_element_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_dynamic_element_data("a")(svelte_element, svelte_element_data);
      add_location(svelte_element, file117, 26, 1, 520);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, svelte_element, anchor);
      if (default_slot) {
        default_slot.m(svelte_element, null);
      }
      ctx[11](svelte_element);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(svelte_element)),
          listen_dev(
            svelte_element,
            "m-blur",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-focus",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-pointerenter",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-pointerleave",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_198
            ),
            get_default_slot_context_198
          );
        }
      }
      set_dynamic_element_data("a")(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6],
        /*attrs*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_dynamic_element5.name,
    type: "child_dynamic_element",
    source: '(27:1) <svelte:element   this={\\"a\\"}   bind:this={el}   {...builder} use:builder.action   {...$$restProps}   {...attrs}   on:m-blur={dispatch}   on:m-focus={dispatch}   on:m-pointerenter={dispatch}   on:m-pointerleave={dispatch}  >',
    ctx
  });
  return block;
}
function create_fragment130(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block115, create_else_block102];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment130.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance130($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Link_preview_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getAttrs: getAttrs2 } = getCtx16();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(8, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function svelte_element_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx16,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    128) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    256) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    attrs,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    svelte_element_binding
  ];
}
var Link_preview_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance130, create_fragment130, safe_not_equal, { asChild: 1, id: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Link_preview_trigger",
      options,
      id: create_fragment130.name
    });
  }
  get asChild() {
    throw new Error("<Link_preview_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Link_preview_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Link_preview_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Link_preview_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Link_preview_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Link_preview_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var link_preview_trigger_default = Link_preview_trigger;

// node_modules/bits-ui/dist/bits/menubar/index.js
var menubar_exports = {};
__export(menubar_exports, {
  Arrow: () => menu_arrow_default,
  CheckboxIndicator: () => menu_checkbox_indicator_default,
  CheckboxItem: () => menu_checkbox_item_default,
  Content: () => menu_content_default,
  Group: () => menu_group_default,
  Item: () => menu_item_default,
  Label: () => menu_label_default,
  Menu: () => menubar_menu_default,
  RadioGroup: () => menu_radio_group_default,
  RadioIndicator: () => menu_radio_indicator_default,
  RadioItem: () => menu_radio_item_default,
  Root: () => menubar_default,
  Separator: () => menu_separator_default,
  Sub: () => menubar_sub_default,
  SubContent: () => menu_sub_content_default,
  SubTrigger: () => menu_sub_trigger_default,
  Trigger: () => menubar_trigger_default
});

// node_modules/bits-ui/dist/bits/menubar/ctx.js
function getMenubarData() {
  const NAME = "menubar";
  const MENU_NAME = "menu";
  const SUB_NAME = "menu-submenu";
  const PARTS = [
    "arrow",
    "checkbox-indicator",
    "checkbox-item",
    "content",
    "group",
    "item",
    "label",
    "radio-group",
    "radio-item",
    "separator",
    "sub-content",
    "sub-trigger",
    "trigger"
  ];
  return {
    NAME,
    MENU_NAME,
    SUB_NAME,
    PARTS
  };
}
function setCtx18(props) {
  const { NAME, PARTS, MENU_NAME } = getMenubarData();
  const getMenubarAttrs = createBitAttrs(NAME, ["root"]);
  const getAttrs2 = createBitAttrs(MENU_NAME, PARTS);
  const menubar = { ...createMenubar(removeUndefined2(props)), getAttrs: getAttrs2, getMenubarAttrs };
  setContext(NAME, menubar);
  return {
    ...menubar,
    updateOption: getOptionUpdater(menubar.options)
  };
}
function getCtx17() {
  const { NAME } = getMenubarData();
  return getContext(NAME);
}
function setMenuCtx(props) {
  const { MENU_NAME } = getMenubarData();
  const { builders: { createMenu }, getAttrs: getAttrs2 } = getCtx17();
  const menu = { ...createMenu({ ...removeUndefined2(props), forceVisible: false }), getAttrs: getAttrs2 };
  setContext(MENU_NAME, menu);
  return {
    ...menu,
    updateOption: getOptionUpdater(menu.options)
  };
}
function getMenuCtx() {
  const { MENU_NAME } = getMenubarData();
  return getContext(MENU_NAME);
}
function setSubMenuCtx2(props) {
  const { SUB_NAME } = getMenubarData();
  const { builders: { createSubmenu }, getAttrs: getAttrs2 } = getMenuCtx();
  const sub = { ...createSubmenu(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(SUB_NAME, sub);
  return {
    ...sub,
    updateOption: getOptionUpdater(sub.options)
  };
}

// node_modules/bits-ui/dist/bits/menubar/components/menubar.svelte
var file118 = "node_modules/bits-ui/dist/bits/menubar/components/menubar.svelte";
var get_default_slot_changes_199 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  ids: dirty & /*$idValues*/
  8
});
var get_default_slot_context_199 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  ids: (
    /*$idValues*/
    ctx[3]
  )
});
var get_default_slot_changes128 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  ids: dirty & /*$idValues*/
  8
});
var get_default_slot_context128 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  ids: (
    /*$idValues*/
    ctx[3]
  )
});
function create_else_block103(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context_199
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file118, 38, 1, 855);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[14](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $idValues*/
        4108)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes_199
            ),
            get_default_slot_context_199
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[14](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block103.name,
    type: "else",
    source: "(38:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block116(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context128
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $idValues*/
        4108)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes128
            ),
            get_default_slot_context128
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block116.name,
    type: "if",
    source: "(36:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment131(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block116, create_else_block103];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment131.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance131($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["loop", "closeOnEscape", "asChild", "id", "preventScroll", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $menubar;
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menubar", slots, ["default"]);
  let { loop = true } = $$props;
  let { closeOnEscape = true } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { preventScroll = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { menubar }, updateOption, ids, getMenubarAttrs } = setCtx18({ loop, closeOnEscape, preventScroll });
  validate_store(menubar, "menubar");
  component_subscribe($$self, menubar, (value) => $$invalidate(11, $menubar = value));
  const idValues = derived([ids.menubar], ([$menubarId]) => ({ menubar: $menubarId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(3, $idValues = value));
  const attrs = getMenubarAttrs("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("loop" in $$new_props) $$invalidate(7, loop = $$new_props.loop);
    if ("closeOnEscape" in $$new_props) $$invalidate(8, closeOnEscape = $$new_props.closeOnEscape);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(9, id = $$new_props.id);
    if ("preventScroll" in $$new_props) $$invalidate(10, preventScroll = $$new_props.preventScroll);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(12, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx18,
    derived,
    loop,
    closeOnEscape,
    asChild,
    id,
    preventScroll,
    el,
    menubar,
    updateOption,
    ids,
    getMenubarAttrs,
    idValues,
    attrs,
    builder,
    $menubar,
    $idValues
  });
  $$self.$inject_state = ($$new_props) => {
    if ("loop" in $$props) $$invalidate(7, loop = $$new_props.loop);
    if ("closeOnEscape" in $$props) $$invalidate(8, closeOnEscape = $$new_props.closeOnEscape);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(9, id = $$new_props.id);
    if ("preventScroll" in $$props) $$invalidate(10, preventScroll = $$new_props.preventScroll);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    512) {
      $: if (id) {
        ids.menubar.set(id);
      }
    }
    if ($$self.$$.dirty & /*loop*/
    128) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    256) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    1024) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*$menubar*/
    2048) {
      $: $$invalidate(2, builder = $menubar);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $idValues,
    menubar,
    idValues,
    $$restProps,
    loop,
    closeOnEscape,
    id,
    preventScroll,
    $menubar,
    $$scope,
    slots,
    div_binding
  ];
}
var Menubar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance131, create_fragment131, safe_not_equal, {
      loop: 7,
      closeOnEscape: 8,
      asChild: 1,
      id: 9,
      preventScroll: 10,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menubar",
      options,
      id: create_fragment131.name
    });
  }
  get loop() {
    throw new Error("<Menubar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Menubar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Menubar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Menubar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Menubar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menubar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Menubar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Menubar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventScroll() {
    throw new Error("<Menubar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Menubar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menubar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menubar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menubar_default = Menubar;

// node_modules/bits-ui/dist/bits/menubar/components/menubar-sub.svelte
var get_default_slot_changes129 = (dirty) => ({ subIds: dirty & /*$idValues*/
1 });
var get_default_slot_context129 = (ctx) => ({ subIds: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment132(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[6].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[5],
    get_default_slot_context129
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        33)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[5],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[5]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[5],
              dirty,
              get_default_slot_changes129
            ),
            get_default_slot_context129
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment132.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance132($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menubar_sub", slots, ["default"]);
  let { disabled = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  const { updateOption, ids, states: { subOpen } } = setSubMenuCtx2({
    disabled,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.menu, ids.trigger], ([$menuId, $triggerId]) => ({ menu: $menuId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = ["disabled", "open", "onOpenChange"];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Menubar_sub> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("disabled" in $$props2) $$invalidate(3, disabled = $$props2.disabled);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(4, onOpenChange = $$props2.onOpenChange);
    if ("$$scope" in $$props2) $$invalidate(5, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setSubMenuCtx: setSubMenuCtx2,
    disabled,
    open,
    onOpenChange,
    updateOption,
    ids,
    subOpen,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("disabled" in $$props2) $$invalidate(3, disabled = $$props2.disabled);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(4, onOpenChange = $$props2.onOpenChange);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && subOpen.set(open);
    }
    if ($$self.$$.dirty & /*disabled*/
    8) {
      $: updateOption("disabled", disabled);
    }
  };
  return [$idValues, idValues, open, disabled, onOpenChange, $$scope, slots];
}
var Menubar_sub = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance132, create_fragment132, safe_not_equal, { disabled: 3, open: 2, onOpenChange: 4 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menubar_sub",
      options,
      id: create_fragment132.name
    });
  }
  get disabled() {
    throw new Error("<Menubar_sub>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Menubar_sub>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Menubar_sub>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Menubar_sub>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Menubar_sub>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Menubar_sub>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menubar_sub_default = Menubar_sub;

// node_modules/bits-ui/dist/bits/menubar/components/menubar-menu.svelte
var get_default_slot_changes130 = (dirty) => ({ menuIds: dirty & /*$idValues*/
1 });
var get_default_slot_context130 = (ctx) => ({ menuIds: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment133(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context130
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        16385)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes130
            ),
            get_default_slot_context130
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment133.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance133($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menubar_menu", slots, ["default"]);
  let { closeOnOutsideClick = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { dir = void 0 } = $$props;
  let { typeahead = void 0 } = $$props;
  let { closeFocus = void 0 } = $$props;
  let { disableFocusFirstItem = void 0 } = $$props;
  let { closeOnItemClick = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { open: localOpen }, updateOption, ids } = setMenuCtx({
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    closeOnItemClick,
    onOutsideClick,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    }
  });
  const idValues = derived([ids.menu, ids.trigger], ([$menuId, $triggerId]) => ({ menu: $menuId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "closeOnOutsideClick",
    "closeOnEscape",
    "portal",
    "open",
    "onOpenChange",
    "loop",
    "dir",
    "typeahead",
    "closeFocus",
    "disableFocusFirstItem",
    "closeOnItemClick",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Menubar_menu> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("closeOnOutsideClick" in $$props2) $$invalidate(3, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(5, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(6, onOpenChange = $$props2.onOpenChange);
    if ("loop" in $$props2) $$invalidate(7, loop = $$props2.loop);
    if ("dir" in $$props2) $$invalidate(8, dir = $$props2.dir);
    if ("typeahead" in $$props2) $$invalidate(9, typeahead = $$props2.typeahead);
    if ("closeFocus" in $$props2) $$invalidate(10, closeFocus = $$props2.closeFocus);
    if ("disableFocusFirstItem" in $$props2) $$invalidate(11, disableFocusFirstItem = $$props2.disableFocusFirstItem);
    if ("closeOnItemClick" in $$props2) $$invalidate(12, closeOnItemClick = $$props2.closeOnItemClick);
    if ("onOutsideClick" in $$props2) $$invalidate(13, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(14, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    setMenuCtx,
    derived,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    open,
    onOpenChange,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    closeOnItemClick,
    onOutsideClick,
    localOpen,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("closeOnOutsideClick" in $$props2) $$invalidate(3, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(5, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(6, onOpenChange = $$props2.onOpenChange);
    if ("loop" in $$props2) $$invalidate(7, loop = $$props2.loop);
    if ("dir" in $$props2) $$invalidate(8, dir = $$props2.dir);
    if ("typeahead" in $$props2) $$invalidate(9, typeahead = $$props2.typeahead);
    if ("closeFocus" in $$props2) $$invalidate(10, closeFocus = $$props2.closeFocus);
    if ("disableFocusFirstItem" in $$props2) $$invalidate(11, disableFocusFirstItem = $$props2.disableFocusFirstItem);
    if ("closeOnItemClick" in $$props2) $$invalidate(12, closeOnItemClick = $$props2.closeOnItemClick);
    if ("onOutsideClick" in $$props2) $$invalidate(13, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    8) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    16) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*portal*/
    32) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*loop*/
    128) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*dir*/
    256) {
      $: updateOption("dir", dir);
    }
    if ($$self.$$.dirty & /*closeFocus*/
    1024) {
      $: updateOption("closeFocus", closeFocus);
    }
    if ($$self.$$.dirty & /*disableFocusFirstItem*/
    2048) {
      $: updateOption("disableFocusFirstItem", disableFocusFirstItem);
    }
    if ($$self.$$.dirty & /*typeahead*/
    512) {
      $: updateOption("typeahead", typeahead);
    }
    if ($$self.$$.dirty & /*closeOnItemClick*/
    4096) {
      $: updateOption("closeOnItemClick", closeOnItemClick);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    8192) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    closeOnOutsideClick,
    closeOnEscape,
    portal,
    onOpenChange,
    loop,
    dir,
    typeahead,
    closeFocus,
    disableFocusFirstItem,
    closeOnItemClick,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Menubar_menu = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance133, create_fragment133, safe_not_equal, {
      closeOnOutsideClick: 3,
      closeOnEscape: 4,
      portal: 5,
      open: 2,
      onOpenChange: 6,
      loop: 7,
      dir: 8,
      typeahead: 9,
      closeFocus: 10,
      disableFocusFirstItem: 11,
      closeOnItemClick: 12,
      onOutsideClick: 13
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menubar_menu",
      options,
      id: create_fragment133.name
    });
  }
  get closeOnOutsideClick() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get dir() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set dir(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get typeahead() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set typeahead(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeFocus() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeFocus(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disableFocusFirstItem() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disableFocusFirstItem(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnItemClick() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnItemClick(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Menubar_menu>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Menubar_menu>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menubar_menu_default = Menubar_menu;

// node_modules/bits-ui/dist/bits/menubar/components/menubar-trigger.svelte
var file119 = "node_modules/bits-ui/dist/bits/menubar/components/menubar-trigger.svelte";
var get_default_slot_changes_1100 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1100 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes131 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context131 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block104(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_1100
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file119, 26, 1, 528);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[10](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-pointerenter",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_1100
            ),
            get_default_slot_context_1100
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block104.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block117(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context131
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes131
            ),
            get_default_slot_context131
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block117.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment134(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block117, create_else_block104];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment134.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance134($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Menubar_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getAttrs: getAttrs2 } = getMenuCtx();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(7, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getMenuCtx,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    128) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Menubar_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance134, create_fragment134, safe_not_equal, { asChild: 1, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Menubar_trigger",
      options,
      id: create_fragment134.name
    });
  }
  get asChild() {
    throw new Error("<Menubar_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Menubar_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Menubar_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Menubar_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Menubar_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Menubar_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var menubar_trigger_default = Menubar_trigger;

// node_modules/bits-ui/dist/bits/pagination/index.js
var pagination_exports = {};
__export(pagination_exports, {
  NextButton: () => pagination_next_button_default,
  Page: () => pagination_page_default,
  PrevButton: () => pagination_prev_button_default,
  Root: () => pagination_default
});

// node_modules/bits-ui/dist/bits/pagination/ctx.js
function getPaginationData() {
  const NAME = "pagination";
  const PARTS = ["root", "prev-button", "next-button", "page"];
  return {
    NAME,
    PARTS
  };
}
function setCtx19(props) {
  const { NAME, PARTS } = getPaginationData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const pagination = { ...createPagination(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, pagination);
  return {
    ...pagination,
    updateOption: getOptionUpdater(pagination.options)
  };
}
function getCtx18() {
  const { NAME } = getPaginationData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/pagination/components/pagination.svelte
var file120 = "node_modules/bits-ui/dist/bits/pagination/components/pagination.svelte";
var get_default_slot_changes_1101 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  pages: dirty & /*$pages*/
  8,
  range: dirty & /*$range*/
  16
});
var get_default_slot_context_1101 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  pages: (
    /*$pages*/
    ctx[3]
  ),
  range: (
    /*$range*/
    ctx[4]
  )
});
var get_default_slot_changes132 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  pages: dirty & /*$pages*/
  8,
  range: dirty & /*$range*/
  16
});
var get_default_slot_context132 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  pages: (
    /*$pages*/
    ctx[3]
  ),
  range: (
    /*$range*/
    ctx[4]
  )
});
function create_else_block105(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_1101
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[8]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file120, 45, 1, 926);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[17](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $pages, $range*/
        32796)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes_1101
            ),
            get_default_slot_context_1101
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        256 && /*$$restProps*/
        ctx2[8]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[17](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block105.name,
    type: "else",
    source: "(45:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block118(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context132
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $pages, $range*/
        32796)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes132
            ),
            get_default_slot_context132
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block118.name,
    type: "if",
    source: "(43:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment135(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block118, create_else_block105];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment135.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance135($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["count", "page", "onPageChange", "perPage", "siblingCount", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let $pages;
  let $range;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Pagination", slots, ["default"]);
  let { count } = $$props;
  let { page = void 0 } = $$props;
  let { onPageChange = void 0 } = $$props;
  let { perPage = void 0 } = $$props;
  let { siblingCount = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { pages, range, page: localPage }, getAttrs: getAttrs2, updateOption } = setCtx19({
    count,
    perPage,
    siblingCount,
    defaultPage: page,
    onPageChange: ({ next: next2 }) => {
      if (page !== next2) {
        onPageChange == null ? void 0 : onPageChange(next2);
        $$invalidate(9, page = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value) => $$invalidate(14, $root = value));
  validate_store(pages, "pages");
  component_subscribe($$self, pages, (value) => $$invalidate(3, $pages = value));
  validate_store(range, "range");
  component_subscribe($$self, range, (value) => $$invalidate(4, $range = value));
  const attrs = getAttrs2("root");
  $$self.$$.on_mount.push(function() {
    if (count === void 0 && !("count" in $$props || $$self.$$.bound[$$self.$$.props["count"]])) {
      console.warn("<Pagination> was created without expected prop 'count'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(8, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("count" in $$new_props) $$invalidate(10, count = $$new_props.count);
    if ("page" in $$new_props) $$invalidate(9, page = $$new_props.page);
    if ("onPageChange" in $$new_props) $$invalidate(11, onPageChange = $$new_props.onPageChange);
    if ("perPage" in $$new_props) $$invalidate(12, perPage = $$new_props.perPage);
    if ("siblingCount" in $$new_props) $$invalidate(13, siblingCount = $$new_props.siblingCount);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(15, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx19,
    count,
    page,
    onPageChange,
    perPage,
    siblingCount,
    asChild,
    el,
    root,
    pages,
    range,
    localPage,
    getAttrs: getAttrs2,
    updateOption,
    attrs,
    builder,
    $root,
    $pages,
    $range
  });
  $$self.$inject_state = ($$new_props) => {
    if ("count" in $$props) $$invalidate(10, count = $$new_props.count);
    if ("page" in $$props) $$invalidate(9, page = $$new_props.page);
    if ("onPageChange" in $$props) $$invalidate(11, onPageChange = $$new_props.onPageChange);
    if ("perPage" in $$props) $$invalidate(12, perPage = $$new_props.perPage);
    if ("siblingCount" in $$props) $$invalidate(13, siblingCount = $$new_props.siblingCount);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*page*/
    512) {
      $: page !== void 0 && localPage.set(page);
    }
    if ($$self.$$.dirty & /*$root*/
    16384) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*count*/
    1024) {
      $: updateOption("count", count);
    }
    if ($$self.$$.dirty & /*perPage*/
    4096) {
      $: updateOption("perPage", perPage);
    }
    if ($$self.$$.dirty & /*siblingCount*/
    8192) {
      $: updateOption("siblingCount", siblingCount);
    }
  };
  return [
    el,
    asChild,
    builder,
    $pages,
    $range,
    root,
    pages,
    range,
    $$restProps,
    page,
    count,
    onPageChange,
    perPage,
    siblingCount,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Pagination = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance135, create_fragment135, safe_not_equal, {
      count: 10,
      page: 9,
      onPageChange: 11,
      perPage: 12,
      siblingCount: 13,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Pagination",
      options,
      id: create_fragment135.name
    });
  }
  get count() {
    throw new Error("<Pagination>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set count(value) {
    throw new Error("<Pagination>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get page() {
    throw new Error("<Pagination>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set page(value) {
    throw new Error("<Pagination>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPageChange() {
    throw new Error("<Pagination>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPageChange(value) {
    throw new Error("<Pagination>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get perPage() {
    throw new Error("<Pagination>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set perPage(value) {
    throw new Error("<Pagination>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get siblingCount() {
    throw new Error("<Pagination>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set siblingCount(value) {
    throw new Error("<Pagination>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Pagination>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Pagination>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Pagination>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Pagination>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var pagination_default = Pagination;

// node_modules/bits-ui/dist/bits/pagination/components/pagination-prev-button.svelte
var file121 = "node_modules/bits-ui/dist/bits/pagination/components/pagination-prev-button.svelte";
var get_default_slot_changes_1102 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1102 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes133 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context133 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block106(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1102
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file121, 20, 1, 456);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1102
            ),
            get_default_slot_context_1102
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block106.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block119(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context133
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes133
            ),
            get_default_slot_context133
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block119.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment136(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block119, create_else_block106];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment136.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance136($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $prevButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Pagination_prev_button", slots, ["default"]);
  let { asChild = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { prevButton }, getAttrs: getAttrs2 } = getCtx18();
  validate_store(prevButton, "prevButton");
  component_subscribe($$self, prevButton, (value) => $$invalidate(6, $prevButton = value));
  const attrs = getAttrs2("prev-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    getCtx: getCtx18,
    melt,
    asChild,
    el,
    prevButton,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $prevButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$prevButton*/
    64) {
      $: $$invalidate(2, builder = $prevButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    prevButton,
    dispatch,
    $$restProps,
    $prevButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Pagination_prev_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance136, create_fragment136, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Pagination_prev_button",
      options,
      id: create_fragment136.name
    });
  }
  get asChild() {
    throw new Error("<Pagination_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Pagination_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Pagination_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Pagination_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var pagination_prev_button_default = Pagination_prev_button;

// node_modules/bits-ui/dist/bits/pagination/components/pagination-next-button.svelte
var file122 = "node_modules/bits-ui/dist/bits/pagination/components/pagination-next-button.svelte";
var get_default_slot_changes_1103 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1103 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes134 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context134 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block107(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1103
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file122, 20, 1, 456);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1103
            ),
            get_default_slot_context_1103
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block107.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block120(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context134
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes134
            ),
            get_default_slot_context134
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block120.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment137(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block120, create_else_block107];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment137.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance137($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $nextButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Pagination_next_button", slots, ["default"]);
  let { asChild = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { nextButton }, getAttrs: getAttrs2 } = getCtx18();
  validate_store(nextButton, "nextButton");
  component_subscribe($$self, nextButton, (value) => $$invalidate(6, $nextButton = value));
  const attrs = getAttrs2("next-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    getCtx: getCtx18,
    melt,
    asChild,
    el,
    nextButton,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $nextButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$nextButton*/
    64) {
      $: $$invalidate(2, builder = $nextButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    nextButton,
    dispatch,
    $$restProps,
    $nextButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Pagination_next_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance137, create_fragment137, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Pagination_next_button",
      options,
      id: create_fragment137.name
    });
  }
  get asChild() {
    throw new Error("<Pagination_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Pagination_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Pagination_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Pagination_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var pagination_next_button_default = Pagination_next_button;

// node_modules/bits-ui/dist/bits/pagination/components/pagination-page.svelte
var file123 = "node_modules/bits-ui/dist/bits/pagination/components/pagination-page.svelte";
var get_default_slot_changes_1104 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context_1104 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
var get_default_slot_changes135 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context135 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
function create_else_block108(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_1104
  );
  const default_slot_or_fallback = default_slot || fallback_block8(ctx);
  let button_levels = [
    { type: "button" },
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[6]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot_or_fallback) default_slot_or_fallback.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file123, 21, 1, 474);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[10](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[3].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_1104
            ),
            get_default_slot_context_1104
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*page*/
        4)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        { type: "button" },
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block108.name,
    type: "else",
    source: "(21:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block121(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context135
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes135
            ),
            get_default_slot_context135
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block121.name,
    type: "if",
    source: "(19:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block8(ctx) {
  let t_value = (
    /*page*/
    ctx[2].value + ""
  );
  let t;
  const block = {
    c: function create() {
      t = text(t_value);
    },
    l: function claim(nodes) {
      t = claim_text(nodes, t_value);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*page*/
      4 && t_value !== (t_value = /*page*/
      ctx2[2].value + "")) set_data_dev(t, t_value);
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block8.name,
    type: "fallback",
    source: "(23:18)     ",
    ctx
  });
  return block;
}
function create_fragment138(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block121, create_else_block108];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment138.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance138($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "page", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $pageTrigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Pagination_page", slots, ["default"]);
  let { asChild = void 0 } = $$props;
  let { page } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { pageTrigger }, getAttrs: getAttrs2 } = getCtx18();
  validate_store(pageTrigger, "pageTrigger");
  component_subscribe($$self, pageTrigger, (value) => $$invalidate(7, $pageTrigger = value));
  const attrs = getAttrs2("page");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (page === void 0 && !("page" in $$props || $$self.$$.bound[$$self.$$.props["page"]])) {
      console.warn("<Pagination_page> was created without expected prop 'page'");
    }
  });
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("page" in $$new_props) $$invalidate(2, page = $$new_props.page);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    getCtx: getCtx18,
    melt,
    asChild,
    page,
    el,
    pageTrigger,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $pageTrigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("page" in $$props) $$invalidate(2, page = $$new_props.page);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$pageTrigger, page*/
    132) {
      $: $$invalidate(3, builder = $pageTrigger(page));
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    page,
    builder,
    pageTrigger,
    dispatch,
    $$restProps,
    $pageTrigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Pagination_page = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance138, create_fragment138, safe_not_equal, { asChild: 1, page: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Pagination_page",
      options,
      id: create_fragment138.name
    });
  }
  get asChild() {
    throw new Error("<Pagination_page>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Pagination_page>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get page() {
    throw new Error("<Pagination_page>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set page(value) {
    throw new Error("<Pagination_page>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Pagination_page>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Pagination_page>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var pagination_page_default = Pagination_page;

// node_modules/bits-ui/dist/bits/pin-input/index.js
var pin_input_exports = {};
__export(pin_input_exports, {
  HiddenInput: () => pin_input_hidden_input_default,
  Input: () => pin_input_input_default,
  Root: () => pin_input_default
});

// node_modules/bits-ui/dist/bits/pin-input/ctx.js
function getPinInputData() {
  const NAME = "pin-input";
  const PARTS = ["root", "input", "hidden-input"];
  return {
    NAME,
    PARTS
  };
}
function setCtx20(props) {
  const { NAME, PARTS } = getPinInputData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const pinInput = { ...createPinInput(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, pinInput);
  return {
    ...pinInput,
    updateOption: getOptionUpdater(pinInput.options)
  };
}
function getCtx19() {
  const { NAME } = getPinInputData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/pin-input/components/pin-input.svelte
var file124 = "node_modules/bits-ui/dist/bits/pin-input/components/pin-input.svelte";
var get_default_slot_spread_changes_1 = (dirty) => dirty & /*slotProps*/
8;
var get_default_slot_changes_1105 = (dirty) => ({});
var get_default_slot_context_1105 = (ctx) => ({ .../*slotProps*/
ctx[3] });
var get_default_slot_spread_changes = (dirty) => dirty & /*slotProps*/
8;
var get_default_slot_changes136 = (dirty) => ({});
var get_default_slot_context136 = (ctx) => ({ .../*slotProps*/
ctx[3] });
function create_else_block109(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[17].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[16],
    get_default_slot_context_1105
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file124, 64, 1, 1225);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[18](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, slotProps*/
        65544)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[16],
            get_default_slot_spread_changes_1(dirty) || !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[16]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[16],
              dirty,
              get_default_slot_changes_1105
            ),
            get_default_slot_context_1105
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[18](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block109.name,
    type: "else",
    source: "(64:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block122(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[17].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[16],
    get_default_slot_context136
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, slotProps*/
        65544)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[16],
            get_default_slot_spread_changes(dirty) || !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[16]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[16],
              dirty,
              get_default_slot_changes136
            ),
            get_default_slot_context136
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block122.name,
    type: "if",
    source: "(62:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment139(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block122, create_else_block109];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment139.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance139($$self, $$props, $$invalidate) {
  let builder;
  let slotProps;
  const omit_props_names = [
    "placeholder",
    "value",
    "name",
    "disabled",
    "type",
    "onValueChange",
    "id",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $idValues;
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Pin_input", slots, ["default"]);
  let { placeholder = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { name: name27 = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { type = "text" } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { id = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { value: localValue }, updateOption, ids, getAttrs: getAttrs2 } = setCtx20({
    placeholder,
    defaultValue: value,
    name: name27,
    disabled,
    type,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(7, value = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(15, $root = value2));
  const attrs = getAttrs2("root");
  const idValues = derived([ids.root], ([$menubarId]) => ({ menubar: $menubarId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value2) => $$invalidate(14, $idValues = value2));
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("placeholder" in $$new_props) $$invalidate(8, placeholder = $$new_props.placeholder);
    if ("value" in $$new_props) $$invalidate(7, value = $$new_props.value);
    if ("name" in $$new_props) $$invalidate(9, name27 = $$new_props.name);
    if ("disabled" in $$new_props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("type" in $$new_props) $$invalidate(11, type = $$new_props.type);
    if ("onValueChange" in $$new_props) $$invalidate(12, onValueChange = $$new_props.onValueChange);
    if ("id" in $$new_props) $$invalidate(13, id = $$new_props.id);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(16, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx20,
    derived,
    placeholder,
    value,
    name: name27,
    disabled,
    type,
    onValueChange,
    id,
    asChild,
    el,
    root,
    localValue,
    updateOption,
    ids,
    getAttrs: getAttrs2,
    attrs,
    idValues,
    builder,
    slotProps,
    $idValues,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("placeholder" in $$props) $$invalidate(8, placeholder = $$new_props.placeholder);
    if ("value" in $$props) $$invalidate(7, value = $$new_props.value);
    if ("name" in $$props) $$invalidate(9, name27 = $$new_props.name);
    if ("disabled" in $$props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("type" in $$props) $$invalidate(11, type = $$new_props.type);
    if ("onValueChange" in $$props) $$invalidate(12, onValueChange = $$new_props.onValueChange);
    if ("id" in $$props) $$invalidate(13, id = $$new_props.id);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
    if ("slotProps" in $$props) $$invalidate(3, slotProps = $$new_props.slotProps);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    128) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*placeholder*/
    256) {
      $: updateOption("placeholder", placeholder);
    }
    if ($$self.$$.dirty & /*name*/
    512) {
      $: updateOption("name", name27);
    }
    if ($$self.$$.dirty & /*disabled*/
    1024) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*type*/
    2048) {
      $: updateOption("type", type);
    }
    if ($$self.$$.dirty & /*$root*/
    32768) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*id*/
    8192) {
      $: if (id) {
        ids.root.set(id);
      }
    }
    if ($$self.$$.dirty & /*builder, $idValues*/
    16388) {
      $: $$invalidate(3, slotProps = { builder, ids: $idValues });
    }
  };
  return [
    el,
    asChild,
    builder,
    slotProps,
    root,
    idValues,
    $$restProps,
    value,
    placeholder,
    name27,
    disabled,
    type,
    onValueChange,
    id,
    $idValues,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Pin_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance139, create_fragment139, safe_not_equal, {
      placeholder: 8,
      value: 7,
      name: 9,
      disabled: 10,
      type: 11,
      onValueChange: 12,
      id: 13,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Pin_input",
      options,
      id: create_fragment139.name
    });
  }
  get placeholder() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get name() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set name(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get type() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set type(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Pin_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Pin_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var pin_input_default = Pin_input;

// node_modules/bits-ui/dist/bits/pin-input/components/pin-input-input.svelte
var file125 = "node_modules/bits-ui/dist/bits/pin-input/components/pin-input-input.svelte";
var get_default_slot_changes137 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context137 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block110(ctx) {
  let input_1;
  let builder_action_action;
  let mounted;
  let dispose;
  let input_1_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let input_data = {};
  for (let i = 0; i < input_1_levels.length; i += 1) {
    input_data = assign(input_data, input_1_levels[i]);
  }
  const block = {
    c: function create() {
      input_1 = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input_1 = claim_element(nodes, "INPUT", {});
      this.h();
    },
    h: function hydrate() {
      set_attributes(input_1, input_data);
      add_location(input_1, file125, 20, 1, 441);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input_1, anchor);
      if (input_1.autofocus) input_1.focus();
      ctx[9](input_1);
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(input_1)),
          listen_dev(
            input_1,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            input_1,
            "m-input",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            input_1,
            "m-paste",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            input_1,
            "m-change",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            input_1,
            "m-focus",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            input_1,
            "m-blur",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(input_1, input_data = get_spread_update(input_1_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input_1);
      }
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block110.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block123(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context137
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes137
            ),
            get_default_slot_context137
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block123.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment140(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block123, create_else_block110];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment140.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance140($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $input;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Pin_input_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { input }, getAttrs: getAttrs2 } = getCtx19();
  validate_store(input, "input");
  component_subscribe($$self, input, (value) => $$invalidate(6, $input = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("input");
  function input_1_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx19,
    createDispatcher,
    asChild,
    el,
    input,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $input
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$input*/
    64) {
      $: $$invalidate(2, builder = $input());
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    input,
    dispatch,
    $$restProps,
    $input,
    $$scope,
    slots,
    input_1_binding
  ];
}
var Pin_input_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance140, create_fragment140, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Pin_input_input",
      options,
      id: create_fragment140.name
    });
  }
  get asChild() {
    throw new Error("<Pin_input_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Pin_input_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Pin_input_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Pin_input_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var pin_input_input_default = Pin_input_input;

// node_modules/bits-ui/dist/bits/pin-input/components/pin-input-hidden-input.svelte
var file126 = "node_modules/bits-ui/dist/bits/pin-input/components/pin-input-hidden-input.svelte";
var get_default_slot_changes138 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context138 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block111(ctx) {
  let input;
  let builder_action_action;
  let mounted;
  let dispose;
  let input_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let input_data = {};
  for (let i = 0; i < input_levels.length; i += 1) {
    input_data = assign(input_data, input_levels[i]);
  }
  const block = {
    c: function create() {
      input = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input = claim_element(nodes, "INPUT", {});
      this.h();
    },
    h: function hydrate() {
      set_attributes(input, input_data);
      add_location(input, file126, 23, 1, 435);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input, anchor);
      if (input.autofocus) input.focus();
      ctx[11](input);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(input));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(input, input_data = get_spread_update(input_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input);
      }
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block111.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block124(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context138
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes138
            ),
            get_default_slot_context138
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block124.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment141(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block124, create_else_block111];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment141.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance141($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $hiddenInput;
  let $disabled;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Pin_input_hidden_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { hiddenInput }, options: { disabled }, getAttrs: getAttrs2 } = getCtx19();
  validate_store(hiddenInput, "hiddenInput");
  component_subscribe($$self, hiddenInput, (value) => $$invalidate(7, $hiddenInput = value));
  validate_store(disabled, "disabled");
  component_subscribe($$self, disabled, (value) => $$invalidate(8, $disabled = value));
  function input_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx19,
    asChild,
    el,
    hiddenInput,
    disabled,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $hiddenInput,
    $disabled
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(6, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$disabled*/
    256) {
      $: $$invalidate(6, attrs = {
        ...getAttrs2("hidden-input"),
        disabled: $disabled ? true : void 0
      });
    }
    if ($$self.$$.dirty & /*$hiddenInput*/
    128) {
      $: $$invalidate(2, builder = $hiddenInput);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    68) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    hiddenInput,
    disabled,
    $$restProps,
    attrs,
    $hiddenInput,
    $disabled,
    $$scope,
    slots,
    input_binding
  ];
}
var Pin_input_hidden_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance141, create_fragment141, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Pin_input_hidden_input",
      options,
      id: create_fragment141.name
    });
  }
  get asChild() {
    throw new Error("<Pin_input_hidden_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Pin_input_hidden_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Pin_input_hidden_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Pin_input_hidden_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var pin_input_hidden_input_default = Pin_input_hidden_input;

// node_modules/bits-ui/dist/bits/popover/index.js
var popover_exports = {};
__export(popover_exports, {
  Arrow: () => popover_arrow_default,
  Close: () => popover_close_default,
  Content: () => popover_content_default,
  Root: () => popover_default,
  Trigger: () => popover_trigger_default
});

// node_modules/bits-ui/dist/bits/popover/components/popover.svelte
var get_default_slot_changes139 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context139 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment142(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context139
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        4097)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes139
            ),
            get_default_slot_context139
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment142.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance142($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Popover", slots, ["default"]);
  let { disableFocusTrap = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { closeOnOutsideClick = void 0 } = $$props;
  let { preventScroll = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { openFocus = void 0 } = $$props;
  let { closeFocus = void 0 } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { updateOption, states: { open: localOpen }, ids } = setCtx12({
    disableFocusTrap,
    closeOnEscape,
    closeOnOutsideClick,
    preventScroll,
    portal,
    defaultOpen: open,
    openFocus,
    closeFocus,
    onOutsideClick,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    },
    positioning: { gutter: 0, offset: { mainAxis: 1 } }
  });
  const idValues = derived([ids.content, ids.trigger], ([$contentId, $triggerId]) => ({ content: $contentId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "disableFocusTrap",
    "closeOnEscape",
    "closeOnOutsideClick",
    "preventScroll",
    "portal",
    "open",
    "onOpenChange",
    "openFocus",
    "closeFocus",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Popover> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("disableFocusTrap" in $$props2) $$invalidate(3, disableFocusTrap = $$props2.disableFocusTrap);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(5, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("preventScroll" in $$props2) $$invalidate(6, preventScroll = $$props2.preventScroll);
    if ("portal" in $$props2) $$invalidate(7, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(8, onOpenChange = $$props2.onOpenChange);
    if ("openFocus" in $$props2) $$invalidate(9, openFocus = $$props2.openFocus);
    if ("closeFocus" in $$props2) $$invalidate(10, closeFocus = $$props2.closeFocus);
    if ("onOutsideClick" in $$props2) $$invalidate(11, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(12, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    setCtx: setCtx12,
    derived,
    disableFocusTrap,
    closeOnEscape,
    closeOnOutsideClick,
    preventScroll,
    portal,
    open,
    onOpenChange,
    openFocus,
    closeFocus,
    onOutsideClick,
    updateOption,
    localOpen,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("disableFocusTrap" in $$props2) $$invalidate(3, disableFocusTrap = $$props2.disableFocusTrap);
    if ("closeOnEscape" in $$props2) $$invalidate(4, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(5, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("preventScroll" in $$props2) $$invalidate(6, preventScroll = $$props2.preventScroll);
    if ("portal" in $$props2) $$invalidate(7, portal = $$props2.portal);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(8, onOpenChange = $$props2.onOpenChange);
    if ("openFocus" in $$props2) $$invalidate(9, openFocus = $$props2.openFocus);
    if ("closeFocus" in $$props2) $$invalidate(10, closeFocus = $$props2.closeFocus);
    if ("onOutsideClick" in $$props2) $$invalidate(11, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*disableFocusTrap*/
    8) {
      $: updateOption("disableFocusTrap", disableFocusTrap);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    16) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    32) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    64) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*portal*/
    128) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*openFocus*/
    512) {
      $: updateOption("openFocus", openFocus);
    }
    if ($$self.$$.dirty & /*closeFocus*/
    1024) {
      $: updateOption("closeFocus", closeFocus);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    2048) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    disableFocusTrap,
    closeOnEscape,
    closeOnOutsideClick,
    preventScroll,
    portal,
    onOpenChange,
    openFocus,
    closeFocus,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Popover = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance142, create_fragment142, safe_not_equal, {
      disableFocusTrap: 3,
      closeOnEscape: 4,
      closeOnOutsideClick: 5,
      preventScroll: 6,
      portal: 7,
      open: 2,
      onOpenChange: 8,
      openFocus: 9,
      closeFocus: 10,
      onOutsideClick: 11
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Popover",
      options,
      id: create_fragment142.name
    });
  }
  get disableFocusTrap() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disableFocusTrap(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnOutsideClick() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventScroll() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get openFocus() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set openFocus(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeFocus() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeFocus(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Popover>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Popover>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var popover_default = Popover;

// node_modules/bits-ui/dist/bits/popover/components/popover-arrow.svelte
var file127 = "node_modules/bits-ui/dist/bits/popover/components/popover-arrow.svelte";
var get_default_slot_changes140 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context140 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block112(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file127, 19, 1, 367);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block112.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block125(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context140
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes140
            ),
            get_default_slot_context140
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block125.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment143(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block125, create_else_block112];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment143.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance143($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "size"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Popover_arrow", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { size: size3 = 8 } = $$props;
  const { elements: { arrow: arrow3 }, getAttrs: getAttrs2 } = setArrow3(size3);
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getAttrs2("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    setArrow: setArrow3,
    melt,
    asChild,
    el,
    size: size3,
    arrow: arrow3,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Popover_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance143, create_fragment143, safe_not_equal, { asChild: 1, el: 0, size: 5 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Popover_arrow",
      options,
      id: create_fragment143.name
    });
  }
  get asChild() {
    throw new Error("<Popover_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Popover_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Popover_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Popover_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get size() {
    throw new Error("<Popover_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Popover_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var popover_arrow_default = Popover_arrow;

// node_modules/bits-ui/dist/bits/popover/components/popover-content.svelte
var file128 = "node_modules/bits-ui/dist/bits/popover/components/popover-content.svelte";
var get_default_slot_changes_512 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_512 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_412 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_412 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_312 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_312 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_212 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_212 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_1106 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_1106 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes141 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context141 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_514(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_512
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file128, 80, 1, 2048);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[26],
              dirty,
              get_default_slot_changes_512
            ),
            get_default_slot_context_512
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx2[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_514.name,
    type: "if",
    source: "(80:16) ",
    ctx
  });
  return block;
}
function create_if_block_414(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_412
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file128, 76, 1, 1891);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[31](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_412
            ),
            get_default_slot_context_412
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[31](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_414.name,
    type: "if",
    source: "(76:33) ",
    ctx
  });
  return block;
}
function create_if_block_314(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_312
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file128, 72, 1, 1720);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[30](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_312
            ),
            get_default_slot_context_312
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[30](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_314.name,
    type: "if",
    source: "(72:32) ",
    ctx
  });
  return block;
}
function create_if_block_214(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_212
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file128, 62, 1, 1498);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_212
            ),
            get_default_slot_context_212
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_214.name,
    type: "if",
    source: "(62:49) ",
    ctx
  });
  return block;
}
function create_if_block_117(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context_1106
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[12]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file128, 58, 1, 1307);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[28](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[8].action(div));
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[26],
              dirty,
              get_default_slot_changes_1106
            ),
            get_default_slot_context_1106
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        4096 && /*$$restProps*/
        ctx[12]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[28](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_117.name,
    type: "if",
    source: "(58:30) ",
    ctx
  });
  return block;
}
function create_if_block126(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[27].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[26],
    get_default_slot_context141
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        67109120)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[26],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[26]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[26],
              dirty,
              get_default_slot_changes141
            ),
            get_default_slot_context141
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block126.name,
    type: "if",
    source: "(56:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment144(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block126,
    create_if_block_117,
    create_if_block_214,
    create_if_block_314,
    create_if_block_414,
    create_if_block_514
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment144.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance144($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $open;
  let $content;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Popover_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "bottom" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = false } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx11();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(25, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const attrs = getAttrs2("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(12, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(13, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(14, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(15, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(16, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(17, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(18, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(19, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(20, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(21, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(22, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(23, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(24, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(26, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx11,
    updatePositioning: updatePositioning5,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    content,
    open,
    ids,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $open,
    $content
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(13, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(14, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(15, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(16, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(17, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(18, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(19, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(20, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(21, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(22, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(23, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(24, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    8192) {
      $: if (id) {
        ids.content.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$content*/
    33554432) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*$open, side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    33538560) {
      $: if ($open) {
        updatePositioning5({
          side,
          align,
          sideOffset,
          alignOffset,
          collisionPadding,
          avoidCollisions,
          collisionBoundary,
          sameWidth,
          fitViewport,
          strategy,
          overlap
        });
      }
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $content,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Popover_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance144,
      create_fragment144,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 13,
        side: 14,
        align: 15,
        sideOffset: 16,
        alignOffset: 17,
        collisionPadding: 18,
        avoidCollisions: 19,
        collisionBoundary: 20,
        sameWidth: 21,
        fitViewport: 22,
        strategy: 23,
        overlap: 24,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Popover_content",
      options,
      id: create_fragment144.name
    });
  }
  get transition() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Popover_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Popover_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var popover_content_default = Popover_content;

// node_modules/bits-ui/dist/bits/popover/components/popover-trigger.svelte
var file129 = "node_modules/bits-ui/dist/bits/popover/components/popover-trigger.svelte";
var get_default_slot_changes_1107 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1107 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes142 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context142 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block113(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[12].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[11],
    get_default_slot_context_1107
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[6]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file129, 32, 1, 632);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[13](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[5],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        2052)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[11],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[11]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[11],
              dirty,
              get_default_slot_changes_1107
            ),
            get_default_slot_context_1107
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[13](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block113.name,
    type: "else",
    source: "(32:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block127(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[12].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[11],
    get_default_slot_context142
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        2052)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[11],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[11]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[11],
              dirty,
              get_default_slot_changes142
            ),
            get_default_slot_context142
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block127.name,
    type: "if",
    source: "(30:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment145(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block127, create_else_block113];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment145.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance145($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let $open;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Popover_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx11();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(9, $trigger = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(10, $open = value));
  const dispatch = createDispatcher();
  const bitsAttrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(11, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx11,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    open,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    bitsAttrs,
    attrs,
    builder,
    $trigger,
    $open
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(7, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(8, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    128) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$open*/
    1024) {
      $: $$invalidate(8, attrs = {
        ...bitsAttrs,
        "aria-controls": $open ? ids.content : void 0
      });
    }
    if ($$self.$$.dirty & /*$trigger*/
    512) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    260) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    open,
    dispatch,
    $$restProps,
    id,
    attrs,
    $trigger,
    $open,
    $$scope,
    slots,
    button_binding
  ];
}
var Popover_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance145, create_fragment145, safe_not_equal, { asChild: 1, id: 7, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Popover_trigger",
      options,
      id: create_fragment145.name
    });
  }
  get asChild() {
    throw new Error("<Popover_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Popover_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Popover_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Popover_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Popover_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Popover_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var popover_trigger_default = Popover_trigger;

// node_modules/bits-ui/dist/bits/popover/components/popover-close.svelte
var file130 = "node_modules/bits-ui/dist/bits/popover/components/popover-close.svelte";
var get_default_slot_changes_1108 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1108 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes143 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context143 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block114(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1108
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file130, 20, 1, 439);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1108
            ),
            get_default_slot_context_1108
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block114.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block128(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context143
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes143
            ),
            get_default_slot_context143
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block128.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment146(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block128, create_else_block114];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment146.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance146($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $close;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Popover_close", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { close }, getAttrs: getAttrs2 } = getCtx11();
  validate_store(close, "close");
  component_subscribe($$self, close, (value) => $$invalidate(6, $close = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("close");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx11,
    createDispatcher,
    asChild,
    el,
    close,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $close
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$close*/
    64) {
      $: $$invalidate(2, builder = $close);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    close,
    dispatch,
    $$restProps,
    $close,
    $$scope,
    slots,
    button_binding
  ];
}
var Popover_close = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance146, create_fragment146, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Popover_close",
      options,
      id: create_fragment146.name
    });
  }
  get asChild() {
    throw new Error("<Popover_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Popover_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Popover_close>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Popover_close>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var popover_close_default = Popover_close;

// node_modules/bits-ui/dist/bits/progress/index.js
var progress_exports = {};
__export(progress_exports, {
  Root: () => progress_default
});

// node_modules/bits-ui/dist/bits/progress/ctx.js
function getProgressData() {
  const NAME = "progress";
  const PARTS = ["root"];
  return {
    NAME,
    PARTS
  };
}
function setCtx21(props) {
  const { NAME, PARTS } = getProgressData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const progress = { ...createProgress(removeUndefined2(props)), getAttrs: getAttrs2 };
  return {
    ...progress,
    updateOption: getOptionUpdater(progress.options)
  };
}

// node_modules/bits-ui/dist/bits/progress/components/progress.svelte
var file131 = "node_modules/bits-ui/dist/bits/progress/components/progress.svelte";
var get_default_slot_changes_1109 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1109 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes144 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context144 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block115(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_1109
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file131, 35, 1, 682);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_1109
            ),
            get_default_slot_context_1109
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block115.name,
    type: "else",
    source: "(35:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block129(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context144
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes144
            ),
            get_default_slot_context144
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block129.name,
    type: "if",
    source: "(33:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment147(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block129, create_else_block115];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment147.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance147($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["max", "value", "onValueChange", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Progress", slots, ["default"]);
  let { max: max2 = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { value: localValue }, updateOption, getAttrs: getAttrs2 } = setCtx21({
    max: max2,
    defaultValue: value,
    onValueChange: ({ next: next2 }) => {
      onValueChange == null ? void 0 : onValueChange(next2);
      $$invalidate(5, value = next2);
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(8, $root = value2));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("max" in $$new_props) $$invalidate(6, max2 = $$new_props.max);
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(7, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx21,
    max: max2,
    value,
    onValueChange,
    asChild,
    el,
    root,
    localValue,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("max" in $$props) $$invalidate(6, max2 = $$new_props.max);
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(7, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    32) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*max*/
    64) {
      $: updateOption("max", max2);
    }
    if ($$self.$$.dirty & /*$root*/
    256) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    $$restProps,
    value,
    max2,
    onValueChange,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Progress = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance147, create_fragment147, safe_not_equal, {
      max: 6,
      value: 5,
      onValueChange: 7,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Progress",
      options,
      id: create_fragment147.name
    });
  }
  get max() {
    throw new Error("<Progress>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set max(value) {
    throw new Error("<Progress>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Progress>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Progress>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Progress>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Progress>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Progress>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Progress>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Progress>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Progress>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var progress_default = Progress;

// node_modules/bits-ui/dist/bits/radio-group/index.js
var radio_group_exports = {};
__export(radio_group_exports, {
  Input: () => radio_group_input_default,
  Item: () => radio_group_item_default,
  ItemIndicator: () => radio_group_item_indicator_default,
  Root: () => radio_group_default
});

// node_modules/bits-ui/dist/bits/radio-group/ctx.js
function getRadioGroupData() {
  const NAME = "radio-group";
  const ITEM_NAME = "radio-group-item";
  const PARTS = ["root", "item", "input", "item-indicator"];
  return {
    NAME,
    ITEM_NAME,
    PARTS
  };
}
function setCtx22(props) {
  const { NAME, PARTS } = getRadioGroupData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const radioGroup = { ...createRadioGroup(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, radioGroup);
  return {
    ...radioGroup,
    updateOption: getOptionUpdater(radioGroup.options)
  };
}
function getCtx20() {
  const { NAME } = getRadioGroupData();
  return getContext(NAME);
}
function setItemCtx2(value) {
  const { ITEM_NAME } = getRadioGroupData();
  const radioGroup = { ...getCtx20(), value };
  setContext(ITEM_NAME, radioGroup);
  return radioGroup;
}
function getRadioIndicator2() {
  const { ITEM_NAME } = getRadioGroupData();
  return getContext(ITEM_NAME);
}

// node_modules/bits-ui/dist/bits/radio-group/components/radio-group.svelte
var file132 = "node_modules/bits-ui/dist/bits/radio-group/components/radio-group.svelte";
var get_default_slot_changes_1110 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1110 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes145 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context145 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block116(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context_1110
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file132, 49, 1, 983);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[14](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes_1110
            ),
            get_default_slot_context_1110
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[14](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block116.name,
    type: "else",
    source: "(49:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block130(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context145
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes145
            ),
            get_default_slot_context145
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block130.name,
    type: "if",
    source: "(47:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment148(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block130, create_else_block116];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment148.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance148($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "required",
    "disabled",
    "value",
    "onValueChange",
    "loop",
    "orientation",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Radio_group", slots, ["default"]);
  let { required = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { orientation = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { value: localValue }, updateOption, getAttrs: getAttrs2 } = setCtx22({
    required,
    disabled,
    defaultValue: value,
    loop,
    orientation,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(5, value = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(11, $root = value2));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("required" in $$new_props) $$invalidate(6, required = $$new_props.required);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(8, onValueChange = $$new_props.onValueChange);
    if ("loop" in $$new_props) $$invalidate(9, loop = $$new_props.loop);
    if ("orientation" in $$new_props) $$invalidate(10, orientation = $$new_props.orientation);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(12, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx22,
    required,
    disabled,
    value,
    onValueChange,
    loop,
    orientation,
    asChild,
    el,
    root,
    localValue,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("required" in $$props) $$invalidate(6, required = $$new_props.required);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(8, onValueChange = $$new_props.onValueChange);
    if ("loop" in $$props) $$invalidate(9, loop = $$new_props.loop);
    if ("orientation" in $$props) $$invalidate(10, orientation = $$new_props.orientation);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    32) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*required*/
    64) {
      $: updateOption("required", required);
    }
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*loop*/
    512) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*orientation*/
    1024) {
      $: updateOption("orientation", orientation);
    }
    if ($$self.$$.dirty & /*$root*/
    2048) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    $$restProps,
    value,
    required,
    disabled,
    onValueChange,
    loop,
    orientation,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Radio_group = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance148, create_fragment148, safe_not_equal, {
      required: 6,
      disabled: 7,
      value: 5,
      onValueChange: 8,
      loop: 9,
      orientation: 10,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Radio_group",
      options,
      id: create_fragment148.name
    });
  }
  get required() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set required(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get orientation() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set orientation(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Radio_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Radio_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var radio_group_default = Radio_group;

// node_modules/bits-ui/dist/bits/radio-group/components/radio-group-input.svelte
var file133 = "node_modules/bits-ui/dist/bits/radio-group/components/radio-group-input.svelte";
var get_default_slot_changes146 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context146 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block117(ctx) {
  let input;
  let builder_action_action;
  let mounted;
  let dispose;
  let input_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let input_data = {};
  for (let i = 0; i < input_levels.length; i += 1) {
    input_data = assign(input_data, input_levels[i]);
  }
  const block = {
    c: function create() {
      input = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input = claim_element(nodes, "INPUT", {});
      this.h();
    },
    h: function hydrate() {
      set_attributes(input, input_data);
      add_location(input, file133, 18, 1, 350);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input, anchor);
      if (input.autofocus) input.focus();
      ctx[8](input);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(input));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(input, input_data = get_spread_update(input_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input);
      }
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block117.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block131(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context146
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes146
            ),
            get_default_slot_context146
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block131.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment149(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block131, create_else_block117];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment149.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance149($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $hiddenInput;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Radio_group_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { hiddenInput }, getAttrs: getAttrs2 } = getCtx20();
  validate_store(hiddenInput, "hiddenInput");
  component_subscribe($$self, hiddenInput, (value) => $$invalidate(5, $hiddenInput = value));
  const attrs = getAttrs2("input");
  function input_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx20,
    asChild,
    el,
    hiddenInput,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $hiddenInput
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$hiddenInput*/
    32) {
      $: $$invalidate(2, builder = $hiddenInput);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    hiddenInput,
    $$restProps,
    $hiddenInput,
    $$scope,
    slots,
    input_binding
  ];
}
var Radio_group_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance149, create_fragment149, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Radio_group_input",
      options,
      id: create_fragment149.name
    });
  }
  get asChild() {
    throw new Error("<Radio_group_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Radio_group_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Radio_group_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Radio_group_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var radio_group_input_default = Radio_group_input;

// node_modules/bits-ui/dist/bits/radio-group/components/radio-group-item.svelte
var file134 = "node_modules/bits-ui/dist/bits/radio-group/components/radio-group-item.svelte";
var get_default_slot_changes_1111 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1111 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes147 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context147 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block118(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_1111
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file134, 22, 1, 517);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[11](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-focus",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_1111
            ),
            get_default_slot_context_1111
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block118.name,
    type: "else",
    source: "(22:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block132(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context147
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes147
            ),
            get_default_slot_context147
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block132.name,
    type: "if",
    source: "(20:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment150(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block132, create_else_block118];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment150.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance150($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["value", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $item;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Radio_group_item", slots, ["default"]);
  let { value } = $$props;
  let { disabled = false } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { item }, getAttrs: getAttrs2 } = setItemCtx2(value);
  validate_store(item, "item");
  component_subscribe($$self, item, (value2) => $$invalidate(8, $item = value2));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("item");
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Radio_group_item> was created without expected prop 'value'");
    }
  });
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setItemCtx: setItemCtx2,
    createDispatcher,
    value,
    disabled,
    asChild,
    el,
    item,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $item
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$item, value, disabled*/
    448) {
      $: $$invalidate(2, builder = $item({ value, disabled }));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    item,
    dispatch,
    $$restProps,
    value,
    disabled,
    $item,
    $$scope,
    slots,
    button_binding
  ];
}
var Radio_group_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance150, create_fragment150, safe_not_equal, { value: 6, disabled: 7, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Radio_group_item",
      options,
      id: create_fragment150.name
    });
  }
  get value() {
    throw new Error("<Radio_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Radio_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Radio_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Radio_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Radio_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Radio_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Radio_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Radio_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var radio_group_item_default = Radio_group_item;

// node_modules/bits-ui/dist/bits/radio-group/components/radio-group-item-indicator.svelte
var file135 = "node_modules/bits-ui/dist/bits/radio-group/components/radio-group-item-indicator.svelte";
var get_default_slot_changes_1112 = (dirty) => ({ checked: dirty & /*checked*/
4 });
var get_default_slot_context_1112 = (ctx) => ({
  checked: (
    /*checked*/
    ctx[2]
  ),
  attrs: (
    /*attrs*/
    ctx[4]
  )
});
var get_default_slot_changes148 = (dirty) => ({ checked: dirty & /*checked*/
4 });
var get_default_slot_context148 = (ctx) => ({
  checked: (
    /*checked*/
    ctx[2]
  ),
  attrs: (
    /*attrs*/
    ctx[4]
  )
});
function create_else_block119(ctx) {
  let div;
  let current;
  let if_block = (
    /*checked*/
    ctx[2] && create_if_block_118(ctx)
  );
  let div_levels = [
    /*attrs*/
    ctx[4],
    /*$$restProps*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (if_block) if_block.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (if_block) if_block.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file135, 16, 1, 324);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (if_block) if_block.m(div, null);
      ctx[9](div);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (
        /*checked*/
        ctx2[2]
      ) {
        if (if_block) {
          if_block.p(ctx2, dirty);
          if (dirty & /*checked*/
          4) {
            transition_in(if_block, 1);
          }
        } else {
          if_block = create_if_block_118(ctx2);
          if_block.c();
          transition_in(if_block, 1);
          if_block.m(div, null);
        }
      } else if (if_block) {
        group_outros();
        transition_out(if_block, 1, 1, () => {
          if_block = null;
        });
        check_outros();
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        /*attrs*/
        ctx2[4],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (if_block) if_block.d();
      ctx[9](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block119.name,
    type: "else",
    source: "(16:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block133(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context148
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, checked*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes148
            ),
            get_default_slot_context148
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block133.name,
    type: "if",
    source: "(14:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_if_block_118(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1112
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, checked*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1112
            ),
            get_default_slot_context_1112
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_118.name,
    type: "if",
    source: "(18:2) {#if checked}",
    ctx
  });
  return block;
}
function create_fragment151(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block133, create_else_block119];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment151.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance151($$self, $$props, $$invalidate) {
  let checked;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isChecked;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Radio_group_item_indicator", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { helpers: { isChecked }, value, getAttrs: getAttrs2 } = getRadioIndicator2();
  validate_store(isChecked, "isChecked");
  component_subscribe($$self, isChecked, (value2) => $$invalidate(6, $isChecked = value2));
  const attrs = getAttrs2("item-indicator");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getRadioIndicator: getRadioIndicator2,
    asChild,
    el,
    isChecked,
    value,
    getAttrs: getAttrs2,
    attrs,
    checked,
    $isChecked
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("checked" in $$props) $$invalidate(2, checked = $$new_props.checked);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$isChecked*/
    64) {
      $: $$invalidate(2, checked = $isChecked(value));
    }
  };
  return [
    el,
    asChild,
    checked,
    isChecked,
    attrs,
    $$restProps,
    $isChecked,
    $$scope,
    slots,
    div_binding
  ];
}
var Radio_group_item_indicator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance151, create_fragment151, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Radio_group_item_indicator",
      options,
      id: create_fragment151.name
    });
  }
  get asChild() {
    throw new Error("<Radio_group_item_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Radio_group_item_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Radio_group_item_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Radio_group_item_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var radio_group_item_indicator_default = Radio_group_item_indicator;

// node_modules/bits-ui/dist/bits/range-calendar/index.js
var range_calendar_exports = {};
__export(range_calendar_exports, {
  Cell: () => range_calendar_cell_default,
  Day: () => range_calendar_day_default,
  Grid: () => range_calendar_grid_default,
  GridBody: () => range_calendar_grid_body_default,
  GridHead: () => range_calendar_grid_head_default,
  GridRow: () => range_calendar_grid_row_default,
  HeadCell: () => range_calendar_head_cell_default,
  Header: () => range_calendar_header_default,
  Heading: () => range_calendar_heading_default,
  NextButton: () => range_calendar_next_button_default,
  PrevButton: () => range_calendar_prev_button_default,
  Root: () => range_calendar_default
});

// node_modules/bits-ui/dist/bits/range-calendar/ctx.js
function getRangeCalendarData() {
  const NAME = "calendar";
  const PARTS = [
    "root",
    "prev-button",
    "next-button",
    "heading",
    "grid",
    "day",
    "header",
    "grid-head",
    "head-cell",
    "grid-body",
    "cell",
    "grid-row"
  ];
  return { NAME, PARTS };
}
function setCtx23(props) {
  const { NAME, PARTS } = getRangeCalendarData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const rangeCalendar = { ...createRangeCalendar(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, rangeCalendar);
  return {
    ...rangeCalendar,
    updateOption: getOptionUpdater(rangeCalendar.options)
  };
}
function getCtx21() {
  const { NAME } = getRangeCalendarData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar.svelte
var file136 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar.svelte";
var get_default_slot_changes_1113 = (dirty) => ({
  builder: dirty[0] & /*builder*/
  4,
  months: dirty[0] & /*months*/
  16,
  weekdays: dirty[0] & /*$weekdays*/
  32,
  startValue: dirty[0] & /*$localStartValue*/
  8,
  endValue: dirty[0] & /*$endValue*/
  64
});
var get_default_slot_context_1113 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  months: (
    /*months*/
    ctx[4]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[5]
  ),
  startValue: (
    /*$localStartValue*/
    ctx[3]
  ),
  endValue: (
    /*$endValue*/
    ctx[6]
  )
});
var get_default_slot_changes149 = (dirty) => ({
  builder: dirty[0] & /*builder*/
  4,
  months: dirty[0] & /*months*/
  16,
  weekdays: dirty[0] & /*$weekdays*/
  32,
  startValue: dirty[0] & /*$localStartValue*/
  8,
  endValue: dirty[0] & /*$endValue*/
  64
});
var get_default_slot_context149 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  months: (
    /*months*/
    ctx[4]
  ),
  weekdays: (
    /*$weekdays*/
    ctx[5]
  ),
  startValue: (
    /*$localStartValue*/
    ctx[3]
  ),
  endValue: (
    /*$endValue*/
    ctx[6]
  )
});
function create_else_block120(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[38].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[37],
    get_default_slot_context_1113
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file136, 136, 1, 3109);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[39](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(div)),
          listen_dev(
            div,
            "m-keydown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*builder, months, $weekdays, $localStartValue, $endValue*/
        124 | dirty[1] & /*$$scope*/
        64)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[37],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[37]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[37],
              dirty,
              get_default_slot_changes_1113
            ),
            get_default_slot_context_1113
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[39](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block120.name,
    type: "else",
    source: "(136:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block134(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[38].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[37],
    get_default_slot_context149
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*builder, months, $weekdays, $localStartValue, $endValue*/
        124 | dirty[1] & /*$$scope*/
        64)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[37],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[37]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[37],
              dirty,
              get_default_slot_changes149
            ),
            get_default_slot_context149
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block134.name,
    type: "if",
    source: "(128:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment152(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block134, create_else_block120];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, [-1, -1]);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment152.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance152($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "placeholder",
    "onPlaceholderChange",
    "value",
    "onValueChange",
    "preventDeselect",
    "minValue",
    "maxValue",
    "pagedNavigation",
    "weekStartsOn",
    "locale",
    "isDateUnavailable",
    "isDateDisabled",
    "disabled",
    "readonly",
    "fixedWeeks",
    "calendarLabel",
    "asChild",
    "id",
    "weekdayFormat",
    "initialFocus",
    "startValue",
    "numberOfMonths",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $localMonths;
  let $calendar;
  let $localStartValue;
  let $weekdays;
  let $endValue;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar", slots, ["default"]);
  let { placeholder = void 0 } = $$props;
  let { onPlaceholderChange = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { preventDeselect = void 0 } = $$props;
  let { minValue = void 0 } = $$props;
  let { maxValue = void 0 } = $$props;
  let { pagedNavigation = void 0 } = $$props;
  let { weekStartsOn = void 0 } = $$props;
  let { locale = void 0 } = $$props;
  let { isDateUnavailable = void 0 } = $$props;
  let { isDateDisabled = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { readonly: readonly2 = void 0 } = $$props;
  let { fixedWeeks = void 0 } = $$props;
  let { calendarLabel = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { weekdayFormat = void 0 } = $$props;
  let { initialFocus = false } = $$props;
  let { startValue = void 0 } = $$props;
  let { numberOfMonths = void 0 } = $$props;
  let { el = void 0 } = $$props;
  onMount(() => {
    if (!initialFocus || !el) return;
    handleCalendarInitialFocus(el);
  });
  const { elements: { calendar }, states: { value: localValue, placeholder: localPlaceholder, months: localMonths, weekdays, startValue: localStartValue, endValue }, updateOption, ids, getAttrs: getAttrs2 } = setCtx23({
    defaultPlaceholder: placeholder,
    defaultValue: value,
    preventDeselect,
    minValue,
    maxValue,
    pagedNavigation,
    weekStartsOn,
    locale,
    isDateUnavailable,
    isDateDisabled,
    disabled,
    readonly: readonly2,
    fixedWeeks,
    calendarLabel,
    weekdayFormat,
    numberOfMonths,
    onPlaceholderChange: ({ next: next2 }) => {
      if (placeholder !== next2) {
        onPlaceholderChange == null ? void 0 : onPlaceholderChange(next2);
        $$invalidate(14, placeholder = next2);
      }
      return next2;
    },
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(15, value = next2);
      }
      return next2;
    }
  });
  validate_store(calendar, "calendar");
  component_subscribe($$self, calendar, (value2) => $$invalidate(36, $calendar = value2));
  validate_store(localMonths, "localMonths");
  component_subscribe($$self, localMonths, (value2) => $$invalidate(35, $localMonths = value2));
  validate_store(weekdays, "weekdays");
  component_subscribe($$self, weekdays, (value2) => $$invalidate(5, $weekdays = value2));
  validate_store(localStartValue, "localStartValue");
  component_subscribe($$self, localStartValue, (value2) => $$invalidate(3, $localStartValue = value2));
  validate_store(endValue, "endValue");
  component_subscribe($$self, endValue, (value2) => $$invalidate(6, $endValue = value2));
  const attrs = getAttrs2("root");
  const dispatch = createDispatcher();
  let months = $localMonths;
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("placeholder" in $$new_props) $$invalidate(14, placeholder = $$new_props.placeholder);
    if ("onPlaceholderChange" in $$new_props) $$invalidate(17, onPlaceholderChange = $$new_props.onPlaceholderChange);
    if ("value" in $$new_props) $$invalidate(15, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(18, onValueChange = $$new_props.onValueChange);
    if ("preventDeselect" in $$new_props) $$invalidate(19, preventDeselect = $$new_props.preventDeselect);
    if ("minValue" in $$new_props) $$invalidate(20, minValue = $$new_props.minValue);
    if ("maxValue" in $$new_props) $$invalidate(21, maxValue = $$new_props.maxValue);
    if ("pagedNavigation" in $$new_props) $$invalidate(22, pagedNavigation = $$new_props.pagedNavigation);
    if ("weekStartsOn" in $$new_props) $$invalidate(23, weekStartsOn = $$new_props.weekStartsOn);
    if ("locale" in $$new_props) $$invalidate(24, locale = $$new_props.locale);
    if ("isDateUnavailable" in $$new_props) $$invalidate(25, isDateUnavailable = $$new_props.isDateUnavailable);
    if ("isDateDisabled" in $$new_props) $$invalidate(26, isDateDisabled = $$new_props.isDateDisabled);
    if ("disabled" in $$new_props) $$invalidate(27, disabled = $$new_props.disabled);
    if ("readonly" in $$new_props) $$invalidate(28, readonly2 = $$new_props.readonly);
    if ("fixedWeeks" in $$new_props) $$invalidate(29, fixedWeeks = $$new_props.fixedWeeks);
    if ("calendarLabel" in $$new_props) $$invalidate(30, calendarLabel = $$new_props.calendarLabel);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(31, id = $$new_props.id);
    if ("weekdayFormat" in $$new_props) $$invalidate(32, weekdayFormat = $$new_props.weekdayFormat);
    if ("initialFocus" in $$new_props) $$invalidate(33, initialFocus = $$new_props.initialFocus);
    if ("startValue" in $$new_props) $$invalidate(16, startValue = $$new_props.startValue);
    if ("numberOfMonths" in $$new_props) $$invalidate(34, numberOfMonths = $$new_props.numberOfMonths);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(37, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx23,
    createDispatcher,
    onMount,
    handleCalendarInitialFocus,
    placeholder,
    onPlaceholderChange,
    value,
    onValueChange,
    preventDeselect,
    minValue,
    maxValue,
    pagedNavigation,
    weekStartsOn,
    locale,
    isDateUnavailable,
    isDateDisabled,
    disabled,
    readonly: readonly2,
    fixedWeeks,
    calendarLabel,
    asChild,
    id,
    weekdayFormat,
    initialFocus,
    startValue,
    numberOfMonths,
    el,
    calendar,
    localValue,
    localPlaceholder,
    localMonths,
    weekdays,
    localStartValue,
    endValue,
    updateOption,
    ids,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    months,
    builder,
    $localMonths,
    $calendar,
    $localStartValue,
    $weekdays,
    $endValue
  });
  $$self.$inject_state = ($$new_props) => {
    if ("placeholder" in $$props) $$invalidate(14, placeholder = $$new_props.placeholder);
    if ("onPlaceholderChange" in $$props) $$invalidate(17, onPlaceholderChange = $$new_props.onPlaceholderChange);
    if ("value" in $$props) $$invalidate(15, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(18, onValueChange = $$new_props.onValueChange);
    if ("preventDeselect" in $$props) $$invalidate(19, preventDeselect = $$new_props.preventDeselect);
    if ("minValue" in $$props) $$invalidate(20, minValue = $$new_props.minValue);
    if ("maxValue" in $$props) $$invalidate(21, maxValue = $$new_props.maxValue);
    if ("pagedNavigation" in $$props) $$invalidate(22, pagedNavigation = $$new_props.pagedNavigation);
    if ("weekStartsOn" in $$props) $$invalidate(23, weekStartsOn = $$new_props.weekStartsOn);
    if ("locale" in $$props) $$invalidate(24, locale = $$new_props.locale);
    if ("isDateUnavailable" in $$props) $$invalidate(25, isDateUnavailable = $$new_props.isDateUnavailable);
    if ("isDateDisabled" in $$props) $$invalidate(26, isDateDisabled = $$new_props.isDateDisabled);
    if ("disabled" in $$props) $$invalidate(27, disabled = $$new_props.disabled);
    if ("readonly" in $$props) $$invalidate(28, readonly2 = $$new_props.readonly);
    if ("fixedWeeks" in $$props) $$invalidate(29, fixedWeeks = $$new_props.fixedWeeks);
    if ("calendarLabel" in $$props) $$invalidate(30, calendarLabel = $$new_props.calendarLabel);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(31, id = $$new_props.id);
    if ("weekdayFormat" in $$props) $$invalidate(32, weekdayFormat = $$new_props.weekdayFormat);
    if ("initialFocus" in $$props) $$invalidate(33, initialFocus = $$new_props.initialFocus);
    if ("startValue" in $$props) $$invalidate(16, startValue = $$new_props.startValue);
    if ("numberOfMonths" in $$props) $$invalidate(34, numberOfMonths = $$new_props.numberOfMonths);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("months" in $$props) $$invalidate(4, months = $$new_props.months);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[1] & /*id*/
    1) {
      $: if (id) {
        ids.calendar.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$localStartValue*/
    8) {
      $: $$invalidate(16, startValue = $localStartValue);
    }
    if ($$self.$$.dirty[0] & /*value*/
    32768) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty[0] & /*placeholder*/
    16384) {
      $: placeholder !== void 0 && localPlaceholder.set(placeholder);
    }
    if ($$self.$$.dirty[0] & /*preventDeselect*/
    524288) {
      $: updateOption("preventDeselect", preventDeselect);
    }
    if ($$self.$$.dirty[0] & /*minValue*/
    1048576) {
      $: updateOption("minValue", minValue);
    }
    if ($$self.$$.dirty[0] & /*maxValue*/
    2097152) {
      $: updateOption("maxValue", maxValue);
    }
    if ($$self.$$.dirty[0] & /*pagedNavigation*/
    4194304) {
      $: updateOption("pagedNavigation", pagedNavigation);
    }
    if ($$self.$$.dirty[0] & /*weekStartsOn*/
    8388608) {
      $: updateOption("weekStartsOn", weekStartsOn);
    }
    if ($$self.$$.dirty[0] & /*locale*/
    16777216) {
      $: updateOption("locale", locale);
    }
    if ($$self.$$.dirty[0] & /*isDateUnavailable*/
    33554432) {
      $: updateOption("isDateUnavailable", isDateUnavailable);
    }
    if ($$self.$$.dirty[0] & /*isDateDisabled*/
    67108864) {
      $: updateOption("isDateDisabled", isDateDisabled);
    }
    if ($$self.$$.dirty[0] & /*disabled*/
    134217728) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty[0] & /*readonly*/
    268435456) {
      $: updateOption("readonly", readonly2);
    }
    if ($$self.$$.dirty[0] & /*fixedWeeks*/
    536870912) {
      $: updateOption("fixedWeeks", fixedWeeks);
    }
    if ($$self.$$.dirty[0] & /*calendarLabel*/
    1073741824) {
      $: updateOption("calendarLabel", calendarLabel);
    }
    if ($$self.$$.dirty[1] & /*weekdayFormat*/
    2) {
      $: updateOption("weekdayFormat", weekdayFormat);
    }
    if ($$self.$$.dirty[1] & /*numberOfMonths*/
    8) {
      $: updateOption("numberOfMonths", numberOfMonths);
    }
    if ($$self.$$.dirty[1] & /*$calendar*/
    32) {
      $: $$invalidate(2, builder = $calendar);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[1] & /*$localMonths*/
    16) {
      $: $$invalidate(4, months = $localMonths);
    }
  };
  return [
    el,
    asChild,
    builder,
    $localStartValue,
    months,
    $weekdays,
    $endValue,
    calendar,
    localMonths,
    weekdays,
    localStartValue,
    endValue,
    dispatch,
    $$restProps,
    placeholder,
    value,
    startValue,
    onPlaceholderChange,
    onValueChange,
    preventDeselect,
    minValue,
    maxValue,
    pagedNavigation,
    weekStartsOn,
    locale,
    isDateUnavailable,
    isDateDisabled,
    disabled,
    readonly2,
    fixedWeeks,
    calendarLabel,
    id,
    weekdayFormat,
    initialFocus,
    numberOfMonths,
    $localMonths,
    $calendar,
    $$scope,
    slots,
    div_binding
  ];
}
var Range_calendar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance152,
      create_fragment152,
      safe_not_equal,
      {
        placeholder: 14,
        onPlaceholderChange: 17,
        value: 15,
        onValueChange: 18,
        preventDeselect: 19,
        minValue: 20,
        maxValue: 21,
        pagedNavigation: 22,
        weekStartsOn: 23,
        locale: 24,
        isDateUnavailable: 25,
        isDateDisabled: 26,
        disabled: 27,
        readonly: 28,
        fixedWeeks: 29,
        calendarLabel: 30,
        asChild: 1,
        id: 31,
        weekdayFormat: 32,
        initialFocus: 33,
        startValue: 16,
        numberOfMonths: 34,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar",
      options,
      id: create_fragment152.name
    });
  }
  get placeholder() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPlaceholderChange() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPlaceholderChange(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventDeselect() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventDeselect(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get minValue() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set minValue(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get maxValue() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set maxValue(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get pagedNavigation() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set pagedNavigation(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekStartsOn() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekStartsOn(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get locale() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set locale(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateUnavailable() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateUnavailable(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get isDateDisabled() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set isDateDisabled(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get readonly() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set readonly(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fixedWeeks() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fixedWeeks(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get calendarLabel() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set calendarLabel(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get weekdayFormat() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set weekdayFormat(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get initialFocus() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set initialFocus(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get startValue() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set startValue(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get numberOfMonths() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set numberOfMonths(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_default = Range_calendar;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-day.svelte
var file137 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-day.svelte";
var get_default_slot_changes_1114 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  32,
  unavailable: dirty & /*unavailable*/
  16
});
var get_default_slot_context_1114 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[5]
  ),
  unavailable: (
    /*unavailable*/
    ctx[4]
  )
});
var get_default_slot_changes150 = (dirty) => ({
  builder: dirty & /*builder*/
  8,
  disabled: dirty & /*disabled*/
  32,
  unavailable: dirty & /*unavailable*/
  16
});
var get_default_slot_context150 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[3]
  ),
  disabled: (
    /*disabled*/
    ctx[5]
  ),
  unavailable: (
    /*unavailable*/
    ctx[4]
  )
});
function create_else_block121(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context_1114
  );
  const default_slot_or_fallback = default_slot || fallback_block9(ctx);
  let div_levels = [
    /*builder*/
    ctx[3],
    /*$$restProps*/
    ctx[10]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file137, 27, 1, 642);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[17](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[3].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[9],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-focusin",
            /*dispatch*/
            ctx[9],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-mouseenter",
            /*dispatch*/
            ctx[9],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable*/
        32824)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes_1114
            ),
            get_default_slot_context_1114
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*date*/
        2)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*$$restProps*/
        1024 && /*$$restProps*/
        ctx2[10]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[17](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block121.name,
    type: "else",
    source: "(27:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block135(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[16].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[15],
    get_default_slot_context150
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, disabled, unavailable*/
        32824)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[15],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[15]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[15],
              dirty,
              get_default_slot_changes150
            ),
            get_default_slot_context150
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block135.name,
    type: "if",
    source: "(25:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block9(ctx) {
  let t_value = (
    /*date*/
    ctx[1].day + ""
  );
  let t;
  const block = {
    c: function create() {
      t = text(t_value);
    },
    l: function claim(nodes) {
      t = claim_text(nodes, t_value);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*date*/
      2 && t_value !== (t_value = /*date*/
      ctx2[1].day + "")) set_data_dev(t, t_value);
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block9.name,
    type: "fallback",
    source: "(36:43)     ",
    ctx
  });
  return block;
}
function create_fragment153(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block135, create_else_block121];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment153.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance153($$self, $$props, $$invalidate) {
  let builder;
  let disabled;
  let unavailable;
  const omit_props_names = ["date", "month", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateUnavailable;
  let $isDateDisabled;
  let $cell;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_day", slots, ["default"]);
  let { date } = $$props;
  let { month } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { cell }, helpers: { isDateDisabled, isDateUnavailable }, getAttrs: getAttrs2 } = getCtx21();
  validate_store(cell, "cell");
  component_subscribe($$self, cell, (value) => $$invalidate(14, $cell = value));
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(13, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(12, $isDateUnavailable = value));
  const attrs = getAttrs2("day");
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Range_calendar_day> was created without expected prop 'date'");
    }
    if (month === void 0 && !("month" in $$props || $$self.$$.bound[$$self.$$.props["month"]])) {
      console.warn("<Range_calendar_day> was created without expected prop 'month'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(10, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$new_props) $$invalidate(11, month = $$new_props.month);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(15, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx21,
    createDispatcher,
    date,
    month,
    asChild,
    el,
    cell,
    isDateDisabled,
    isDateUnavailable,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    unavailable,
    disabled,
    builder,
    $isDateUnavailable,
    $isDateDisabled,
    $cell
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(1, date = $$new_props.date);
    if ("month" in $$props) $$invalidate(11, month = $$new_props.month);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("unavailable" in $$props) $$invalidate(4, unavailable = $$new_props.unavailable);
    if ("disabled" in $$props) $$invalidate(5, disabled = $$new_props.disabled);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$cell, date, month*/
    18434) {
      $: $$invalidate(3, builder = $cell(date, month));
    }
    if ($$self.$$.dirty & /*builder*/
    8) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$isDateDisabled, date*/
    8194) {
      $: $$invalidate(5, disabled = $isDateDisabled(date));
    }
    if ($$self.$$.dirty & /*$isDateUnavailable, date*/
    4098) {
      $: $$invalidate(4, unavailable = $isDateUnavailable(date));
    }
  };
  return [
    el,
    date,
    asChild,
    builder,
    unavailable,
    disabled,
    cell,
    isDateDisabled,
    isDateUnavailable,
    dispatch,
    $$restProps,
    month,
    $isDateUnavailable,
    $isDateDisabled,
    $cell,
    $$scope,
    slots,
    div_binding
  ];
}
var Range_calendar_day = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance153, create_fragment153, safe_not_equal, { date: 1, month: 11, asChild: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_day",
      options,
      id: create_fragment153.name
    });
  }
  get date() {
    throw new Error("<Range_calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Range_calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get month() {
    throw new Error("<Range_calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set month(value) {
    throw new Error("<Range_calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Range_calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_day>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_day>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_day_default = Range_calendar_day;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid.svelte
var file138 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid.svelte";
var get_default_slot_changes_1115 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1115 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes151 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context151 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block122(ctx) {
  let table;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1115
  );
  let table_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let table_data = {};
  for (let i = 0; i < table_levels.length; i += 1) {
    table_data = assign(table_data, table_levels[i]);
  }
  const block = {
    c: function create() {
      table = element("table");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      table = claim_element(nodes, "TABLE", {});
      var table_nodes = children(table);
      if (default_slot) default_slot.l(table_nodes);
      table_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(table, table_data);
      add_location(table, file138, 18, 1, 335);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, table, anchor);
      if (default_slot) {
        default_slot.m(table, null);
      }
      ctx[8](table);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(table));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1115
            ),
            get_default_slot_context_1115
          );
        }
      }
      set_attributes(table, table_data = get_spread_update(table_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(table);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block122.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block136(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context151
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes151
            ),
            get_default_slot_context151
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block136.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment154(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block136, create_else_block122];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment154.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance154($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $grid;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_grid", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { grid }, getAttrs: getAttrs2 } = getCtx21();
  validate_store(grid, "grid");
  component_subscribe($$self, grid, (value) => $$invalidate(5, $grid = value));
  const attrs = getAttrs2("grid");
  function table_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx21,
    asChild,
    el,
    grid,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $grid
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$grid*/
    32) {
      $: $$invalidate(2, builder = $grid);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, grid, $$restProps, $grid, $$scope, slots, table_binding];
}
var Range_calendar_grid = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance154, create_fragment154, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_grid",
      options,
      id: create_fragment154.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_grid>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_grid>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_grid_default = Range_calendar_grid;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid-body.svelte
var file139 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid-body.svelte";
var get_default_slot_changes152 = (dirty) => ({});
var get_default_slot_context152 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block123(ctx) {
  let tbody;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    null
  );
  let tbody_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tbody_data = {};
  for (let i = 0; i < tbody_levels.length; i += 1) {
    tbody_data = assign(tbody_data, tbody_levels[i]);
  }
  const block = {
    c: function create() {
      tbody = element("tbody");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tbody = claim_element(nodes, "TBODY", {});
      var tbody_nodes = children(tbody);
      if (default_slot) default_slot.l(tbody_nodes);
      tbody_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tbody, tbody_data);
      add_location(tbody, file139, 10, 1, 216);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tbody, anchor);
      if (default_slot) {
        default_slot.m(tbody, null);
      }
      ctx[6](tbody);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(tbody, tbody_data = get_spread_update(tbody_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tbody);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block123.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block137(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context152
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes152
            ),
            get_default_slot_context152
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block137.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment155(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block137, create_else_block123];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment155.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance155($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_grid_body", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getAttrs: getAttrs2 } = getCtx21();
  const attrs = getAttrs2("grid-body");
  function tbody_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({ getCtx: getCtx21, asChild, el, getAttrs: getAttrs2, attrs });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tbody_binding];
}
var Range_calendar_grid_body = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance155, create_fragment155, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_grid_body",
      options,
      id: create_fragment155.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_grid_body>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_grid_body>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_grid_body_default = Range_calendar_grid_body;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-cell.svelte
var file140 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-cell.svelte";
var get_default_slot_changes_1116 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context_1116 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes153 = (dirty) => ({ attrs: dirty & /*attrs*/
4 });
var get_default_slot_context153 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block124(ctx) {
  let td;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_1116
  );
  let td_levels = [
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[2]
  ];
  let td_data = {};
  for (let i = 0; i < td_levels.length; i += 1) {
    td_data = assign(td_data, td_levels[i]);
  }
  const block = {
    c: function create() {
      td = element("td");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      td = claim_element(nodes, "TD", {});
      var td_nodes = children(td);
      if (default_slot) default_slot.l(td_nodes);
      td_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(td, td_data);
      add_location(td, file140, 19, 1, 386);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, td, anchor);
      if (default_slot) {
        default_slot.m(td, null);
      }
      ctx[11](td);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_1116
            ),
            get_default_slot_context_1116
          );
        }
      }
      set_attributes(td, td_data = get_spread_update(td_levels, [
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        dirty & /*attrs*/
        4 && /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(td);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block124.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block138(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context153
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes153
            ),
            get_default_slot_context153
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block138.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment156(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block138, create_else_block124];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment156.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance156($$self, $$props, $$invalidate) {
  let attrs;
  const omit_props_names = ["date", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isDateUnavailable;
  let $isDateDisabled;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_cell", slots, ["default"]);
  let { date } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { helpers: { isDateDisabled, isDateUnavailable }, getAttrs: getAttrs2 } = getCtx21();
  validate_store(isDateDisabled, "isDateDisabled");
  component_subscribe($$self, isDateDisabled, (value) => $$invalidate(8, $isDateDisabled = value));
  validate_store(isDateUnavailable, "isDateUnavailable");
  component_subscribe($$self, isDateUnavailable, (value) => $$invalidate(7, $isDateUnavailable = value));
  $$self.$$.on_mount.push(function() {
    if (date === void 0 && !("date" in $$props || $$self.$$.bound[$$self.$$.props["date"]])) {
      console.warn("<Range_calendar_cell> was created without expected prop 'date'");
    }
  });
  function td_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("date" in $$new_props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx21,
    date,
    asChild,
    el,
    isDateDisabled,
    isDateUnavailable,
    getAttrs: getAttrs2,
    attrs,
    $isDateUnavailable,
    $isDateDisabled
  });
  $$self.$inject_state = ($$new_props) => {
    if ("date" in $$props) $$invalidate(6, date = $$new_props.date);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(2, attrs = $$new_props.attrs);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$isDateDisabled, date, $isDateUnavailable*/
    448) {
      $: $$invalidate(2, attrs = {
        ...getAttrs2("cell"),
        "aria-disabled": $isDateDisabled(date) || $isDateUnavailable(date),
        role: "gridcell"
      });
    }
  };
  return [
    el,
    asChild,
    attrs,
    isDateDisabled,
    isDateUnavailable,
    $$restProps,
    date,
    $isDateUnavailable,
    $isDateDisabled,
    $$scope,
    slots,
    td_binding
  ];
}
var Range_calendar_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance156, create_fragment156, safe_not_equal, { date: 6, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_cell",
      options,
      id: create_fragment156.name
    });
  }
  get date() {
    throw new Error("<Range_calendar_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set date(value) {
    throw new Error("<Range_calendar_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Range_calendar_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_cell_default = Range_calendar_cell;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid-head.svelte
var file141 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid-head.svelte";
var get_default_slot_changes154 = (dirty) => ({});
var get_default_slot_context154 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block125(ctx) {
  let thead;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    null
  );
  let thead_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let thead_data = {};
  for (let i = 0; i < thead_levels.length; i += 1) {
    thead_data = assign(thead_data, thead_levels[i]);
  }
  const block = {
    c: function create() {
      thead = element("thead");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      thead = claim_element(nodes, "THEAD", {});
      var thead_nodes = children(thead);
      if (default_slot) default_slot.l(thead_nodes);
      thead_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(thead, thead_data);
      add_location(thead, file141, 10, 1, 244);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, thead, anchor);
      if (default_slot) {
        default_slot.m(thead, null);
      }
      ctx[6](thead);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(thead, thead_data = get_spread_update(thead_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(thead);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block125.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block139(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context154
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes154
            ),
            get_default_slot_context154
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block139.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment157(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block139, create_else_block125];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment157.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance157($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_grid_head", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getAttrs: getAttrs2 } = getCtx21();
  const attrs = {
    ...getAttrs2("grid-head"),
    "aria-hidden": true
  };
  function thead_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({ getCtx: getCtx21, asChild, el, getAttrs: getAttrs2, attrs });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, thead_binding];
}
var Range_calendar_grid_head = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance157, create_fragment157, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_grid_head",
      options,
      id: create_fragment157.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_grid_head>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_grid_head>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_grid_head_default = Range_calendar_grid_head;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-head-cell.svelte
var file142 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-head-cell.svelte";
var get_default_slot_changes155 = (dirty) => ({});
var get_default_slot_context155 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block126(ctx) {
  let th;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    null
  );
  let th_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let th_data = {};
  for (let i = 0; i < th_levels.length; i += 1) {
    th_data = assign(th_data, th_levels[i]);
  }
  const block = {
    c: function create() {
      th = element("th");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      th = claim_element(nodes, "TH", {});
      var th_nodes = children(th);
      if (default_slot) default_slot.l(th_nodes);
      th_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(th, th_data);
      add_location(th, file142, 10, 1, 216);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, th, anchor);
      if (default_slot) {
        default_slot.m(th, null);
      }
      ctx[6](th);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              null
            ),
            null
          );
        }
      }
      set_attributes(th, th_data = get_spread_update(th_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(th);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block126.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block140(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context155
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes155
            ),
            get_default_slot_context155
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block140.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment158(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block140, create_else_block126];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment158.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance158($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_head_cell", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getAttrs: getAttrs2 } = getCtx21();
  const attrs = getAttrs2("head-cell");
  function th_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({ getCtx: getCtx21, asChild, el, getAttrs: getAttrs2, attrs });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, th_binding];
}
var Range_calendar_head_cell = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance158, create_fragment158, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_head_cell",
      options,
      id: create_fragment158.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_head_cell>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_head_cell>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_head_cell_default = Range_calendar_head_cell;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid-row.svelte
var file143 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-grid-row.svelte";
var get_default_slot_changes_1117 = (dirty) => ({});
var get_default_slot_context_1117 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes156 = (dirty) => ({});
var get_default_slot_context156 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block127(ctx) {
  let tr;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_1117
  );
  let tr_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let tr_data = {};
  for (let i = 0; i < tr_levels.length; i += 1) {
    tr_data = assign(tr_data, tr_levels[i]);
  }
  const block = {
    c: function create() {
      tr = element("tr");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      tr = claim_element(nodes, "TR", {});
      var tr_nodes = children(tr);
      if (default_slot) default_slot.l(tr_nodes);
      tr_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(tr, tr_data);
      add_location(tr, file143, 10, 1, 215);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, tr, anchor);
      if (default_slot) {
        default_slot.m(tr, null);
      }
      ctx[6](tr);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_1117
            ),
            get_default_slot_context_1117
          );
        }
      }
      set_attributes(tr, tr_data = get_spread_update(tr_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(tr);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block127.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block141(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context156
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes156
            ),
            get_default_slot_context156
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block141.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment159(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block141, create_else_block127];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment159.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance159($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_grid_row", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getAttrs: getAttrs2 } = getCtx21();
  const attrs = getAttrs2("grid-row");
  function tr_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({ getCtx: getCtx21, asChild, el, getAttrs: getAttrs2, attrs });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, tr_binding];
}
var Range_calendar_grid_row = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance159, create_fragment159, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_grid_row",
      options,
      id: create_fragment159.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_grid_row>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_grid_row>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_grid_row_default = Range_calendar_grid_row;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-header.svelte
var file144 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-header.svelte";
var get_default_slot_changes_1118 = (dirty) => ({});
var get_default_slot_context_1118 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
var get_default_slot_changes157 = (dirty) => ({});
var get_default_slot_context157 = (ctx) => ({ attrs: (
  /*attrs*/
  ctx[2]
) });
function create_else_block128(ctx) {
  let header;
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_1118
  );
  let header_levels = [
    /*$$restProps*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let header_data = {};
  for (let i = 0; i < header_levels.length; i += 1) {
    header_data = assign(header_data, header_levels[i]);
  }
  const block = {
    c: function create() {
      header = element("header");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      header = claim_element(nodes, "HEADER", {});
      var header_nodes = children(header);
      if (default_slot) default_slot.l(header_nodes);
      header_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(header, header_data);
      add_location(header, file144, 10, 1, 213);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, header, anchor);
      if (default_slot) {
        default_slot.m(header, null);
      }
      ctx[6](header);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_1118
            ),
            get_default_slot_context_1118
          );
        }
      }
      set_attributes(header, header_data = get_spread_update(header_levels, [
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3],
        /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(header);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block128.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block142(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[5].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context157
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope*/
        16)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes157
            ),
            get_default_slot_context157
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block142.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment160(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block142, create_else_block128];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment160.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance160($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_header", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { getAttrs: getAttrs2 } = getCtx21();
  const attrs = getAttrs2("header");
  function header_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({ getCtx: getCtx21, asChild, el, getAttrs: getAttrs2, attrs });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [el, asChild, attrs, $$restProps, $$scope, slots, header_binding];
}
var Range_calendar_header = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance160, create_fragment160, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_header",
      options,
      id: create_fragment160.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_header>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_header>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_header_default = Range_calendar_header;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-heading.svelte
var file145 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-heading.svelte";
var get_default_slot_changes_1119 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context_1119 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
var get_default_slot_changes158 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  headingValue: dirty & /*$headingValue*/
  8
});
var get_default_slot_context158 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  headingValue: (
    /*$headingValue*/
    ctx[3]
  )
});
function create_else_block129(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_1119
  );
  const default_slot_or_fallback = default_slot || fallback_block10(ctx);
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file145, 19, 1, 401);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_1119
            ),
            get_default_slot_context_1119
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*$headingValue*/
        8)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block129.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block143(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context158
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $headingValue*/
        268)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes158
            ),
            get_default_slot_context158
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block143.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block10(ctx) {
  let t;
  const block = {
    c: function create() {
      t = text(
        /*$headingValue*/
        ctx[3]
      );
    },
    l: function claim(nodes) {
      t = claim_text(
        nodes,
        /*$headingValue*/
        ctx[3]
      );
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*$headingValue*/
      8) set_data_dev(
        t,
        /*$headingValue*/
        ctx2[3]
      );
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block10.name,
    type: "fallback",
    source: "(21:47)     ",
    ctx
  });
  return block;
}
function create_fragment161(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block143, create_else_block129];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment161.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance161($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $heading;
  let $headingValue;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_heading", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { heading }, states: { headingValue }, getAttrs: getAttrs2 } = getCtx21();
  validate_store(heading, "heading");
  component_subscribe($$self, heading, (value) => $$invalidate(7, $heading = value));
  validate_store(headingValue, "headingValue");
  component_subscribe($$self, headingValue, (value) => $$invalidate(3, $headingValue = value));
  const attrs = getAttrs2("heading");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx21,
    asChild,
    el,
    heading,
    headingValue,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $heading,
    $headingValue
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$heading*/
    128) {
      $: $$invalidate(2, builder = $heading);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $headingValue,
    heading,
    headingValue,
    $$restProps,
    $heading,
    $$scope,
    slots,
    div_binding
  ];
}
var Range_calendar_heading = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance161, create_fragment161, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_heading",
      options,
      id: create_fragment161.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_heading>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_heading>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_heading_default = Range_calendar_heading;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-next-button.svelte
var file146 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-next-button.svelte";
var get_default_slot_changes_1120 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1120 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes159 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context159 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block130(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1120
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file146, 20, 1, 455);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1120
            ),
            get_default_slot_context_1120
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block130.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block144(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context159
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes159
            ),
            get_default_slot_context159
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block144.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment162(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block144, create_else_block130];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment162.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance162($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $nextButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_next_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { nextButton }, getAttrs: getAttrs2 } = getCtx21();
  validate_store(nextButton, "nextButton");
  component_subscribe($$self, nextButton, (value) => $$invalidate(6, $nextButton = value));
  const attrs = getAttrs2("next-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx21,
    createDispatcher,
    asChild,
    el,
    nextButton,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $nextButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$nextButton*/
    64) {
      $: $$invalidate(2, builder = $nextButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    nextButton,
    dispatch,
    $$restProps,
    $nextButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Range_calendar_next_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance162, create_fragment162, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_next_button",
      options,
      id: create_fragment162.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_next_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_next_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_next_button_default = Range_calendar_next_button;

// node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-prev-button.svelte
var file147 = "node_modules/bits-ui/dist/bits/range-calendar/components/range-calendar-prev-button.svelte";
var get_default_slot_changes_1121 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1121 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes160 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context160 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block131(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1121
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file147, 20, 1, 455);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[9](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1121
            ),
            get_default_slot_context_1121
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block131.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block145(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context160
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes160
            ),
            get_default_slot_context160
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block145.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment163(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block145, create_else_block131];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment163.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance163($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $prevButton;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Range_calendar_prev_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { prevButton }, getAttrs: getAttrs2 } = getCtx21();
  validate_store(prevButton, "prevButton");
  component_subscribe($$self, prevButton, (value) => $$invalidate(6, $prevButton = value));
  const attrs = getAttrs2("prev-button");
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx21,
    createDispatcher,
    asChild,
    el,
    prevButton,
    getAttrs: getAttrs2,
    attrs,
    dispatch,
    builder,
    $prevButton
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$prevButton*/
    64) {
      $: $$invalidate(2, builder = $prevButton);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    prevButton,
    dispatch,
    $$restProps,
    $prevButton,
    $$scope,
    slots,
    button_binding
  ];
}
var Range_calendar_prev_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance163, create_fragment163, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Range_calendar_prev_button",
      options,
      id: create_fragment163.name
    });
  }
  get asChild() {
    throw new Error("<Range_calendar_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Range_calendar_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Range_calendar_prev_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Range_calendar_prev_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var range_calendar_prev_button_default = Range_calendar_prev_button;

// node_modules/bits-ui/dist/bits/scroll-area/index.js
var scroll_area_exports = {};
__export(scroll_area_exports, {
  Content: () => scroll_area_content_default,
  Corner: () => scroll_area_corner_default,
  Root: () => scroll_area_default,
  Scrollbar: () => scroll_area_scrollbar_default,
  Thumb: () => scroll_area_thumb_default,
  Viewport: () => scroll_area_viewport_default
});

// node_modules/bits-ui/dist/bits/scroll-area/ctx.js
function getScrollAreaData() {
  const NAME = "scroll-area";
  const SCROLLBAR_NAME = "scrollbar";
  const PARTS = [
    "scrollbar-x",
    "scrollbar-y",
    "thumb-x",
    "thumb-y",
    "viewport",
    "content",
    "root",
    "corner"
  ];
  return { NAME, PARTS, SCROLLBAR_NAME };
}
function setCtx24(props) {
  const { NAME, PARTS } = getScrollAreaData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const scrollArea = { ...createScrollArea(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, scrollArea);
  return {
    ...scrollArea,
    updateOption: getOptionUpdater(scrollArea.options)
  };
}
function getCtx22() {
  const { NAME } = getScrollAreaData();
  return getContext(NAME);
}
function setScrollbarOrientation(orientation) {
  const { SCROLLBAR_NAME } = getScrollAreaData();
  return setContext(SCROLLBAR_NAME, orientation);
}
function getScrollbarOrientation() {
  const { SCROLLBAR_NAME } = getScrollAreaData();
  return getContext(SCROLLBAR_NAME);
}

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area.svelte
var file148 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area.svelte";
var get_default_slot_changes_1122 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context_1122 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
var get_default_slot_changes161 = (dirty) => ({ builder: dirty & /*builder*/
8 });
var get_default_slot_context161 = (ctx) => ({ builder: (
  /*builder*/
  ctx[3]
) });
function create_else_block132(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_1122
  );
  let div_levels = [
    /*builder*/
    ctx[3],
    /*attrs*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file148, 42, 1, 754);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[11](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[3].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        520)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_1122
            ),
            get_default_slot_context_1122
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        8 && /*builder*/
        ctx2[3],
        dirty & /*attrs*/
        4 && /*attrs*/
        ctx2[2]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block132.name,
    type: "else",
    source: "(42:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block146(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context161
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        520)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes161
            ),
            get_default_slot_context161
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block146.name,
    type: "if",
    source: "(40:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment164(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block146, create_else_block132];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment164.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance164($$self, $$props, $$invalidate) {
  let builder;
  let attrs;
  const omit_props_names = ["type", "dir", "hideDelay", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area", slots, ["default"]);
  let { type = "hover" } = $$props;
  let { dir = "ltr" } = $$props;
  let { hideDelay = 600 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, updateOption, getAttrs: getAttrs2 } = setCtx24({ type, dir, hideDelay });
  validate_store(root, "root");
  component_subscribe($$self, root, (value) => $$invalidate(8, $root = value));
  const bitsAttrs = getAttrs2("root");
  const style = styleToString2({ overflow: "hidden" });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(16, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("type" in $$new_props) $$invalidate(5, type = $$new_props.type);
    if ("dir" in $$new_props) $$invalidate(6, dir = $$new_props.dir);
    if ("hideDelay" in $$new_props) $$invalidate(7, hideDelay = $$new_props.hideDelay);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx24,
    styleToString: styleToString2,
    type,
    dir,
    hideDelay,
    asChild,
    el,
    root,
    updateOption,
    getAttrs: getAttrs2,
    bitsAttrs,
    style,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("type" in $$props) $$invalidate(5, type = $$new_props.type);
    if ("dir" in $$props) $$invalidate(6, dir = $$new_props.dir);
    if ("hideDelay" in $$props) $$invalidate(7, hideDelay = $$new_props.hideDelay);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(2, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(3, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$root*/
    256) {
      $: $$invalidate(3, builder = $root);
    }
    if ($$self.$$.dirty & /*type*/
    32) {
      $: updateOption("type", type);
    }
    if ($$self.$$.dirty & /*dir*/
    64) {
      $: updateOption("dir", dir);
    }
    if ($$self.$$.dirty & /*hideDelay*/
    128) {
      $: updateOption("hideDelay", hideDelay);
    }
    $: $$invalidate(2, attrs = { ...$$restProps, ...bitsAttrs, style });
    if ($$self.$$.dirty & /*builder, attrs*/
    12) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    attrs,
    builder,
    root,
    type,
    dir,
    hideDelay,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Scroll_area = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance164, create_fragment164, safe_not_equal, {
      type: 5,
      dir: 6,
      hideDelay: 7,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area",
      options,
      id: create_fragment164.name
    });
  }
  get type() {
    throw new Error("<Scroll_area>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set type(value) {
    throw new Error("<Scroll_area>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get dir() {
    throw new Error("<Scroll_area>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set dir(value) {
    throw new Error("<Scroll_area>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get hideDelay() {
    throw new Error("<Scroll_area>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set hideDelay(value) {
    throw new Error("<Scroll_area>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Scroll_area>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_default = Scroll_area;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-viewport.svelte
var file149 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-viewport.svelte";
var get_default_slot_changes_1123 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1123 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes162 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context162 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block133(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1123
  );
  let div_levels = [
    /*builder*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file149, 23, 1, 408);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1123
            ),
            get_default_slot_context_1123
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [dirty & /*builder*/
      4 && /*builder*/
      ctx2[2]]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block133.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block147(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context162
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes162
            ),
            get_default_slot_context162
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block147.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment165(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block147, create_else_block133];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment165.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance165($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $viewport;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_viewport", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { viewport }, getAttrs: getAttrs2 } = getCtx22();
  validate_store(viewport, "viewport");
  component_subscribe($$self, viewport, (value) => $$invalidate(5, $viewport = value));
  const bitsAttrs = getAttrs2("viewport");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx22,
    melt,
    asChild,
    el,
    viewport,
    getAttrs: getAttrs2,
    bitsAttrs,
    attrs,
    builder,
    $viewport
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(4, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    $: $$invalidate(4, attrs = { ...$$restProps, ...bitsAttrs });
    if ($$self.$$.dirty & /*$viewport*/
    32) {
      $: $$invalidate(2, builder = $viewport);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    20) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, viewport, attrs, $viewport, $$scope, slots, div_binding];
}
var Scroll_area_viewport = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance165, create_fragment165, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_viewport",
      options,
      id: create_fragment165.name
    });
  }
  get asChild() {
    throw new Error("<Scroll_area_viewport>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area_viewport>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area_viewport>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area_viewport>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_viewport_default = Scroll_area_viewport;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-content.svelte
var file150 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-content.svelte";
var get_default_slot_changes_1124 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1124 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes163 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context163 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block134(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1124
  );
  let div_levels = [
    /*builder*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file150, 23, 1, 405);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1124
            ),
            get_default_slot_context_1124
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [dirty & /*builder*/
      4 && /*builder*/
      ctx2[2]]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block134.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block148(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context163
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes163
            ),
            get_default_slot_context163
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block148.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment166(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block148, create_else_block134];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment166.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance166($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_content", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, getAttrs: getAttrs2 } = getCtx22();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(5, $content = value));
  const bitsAttrs = getAttrs2("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx22,
    melt,
    asChild,
    el,
    content,
    getAttrs: getAttrs2,
    bitsAttrs,
    attrs,
    builder,
    $content
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(4, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    $: $$invalidate(4, attrs = { ...$$restProps, ...bitsAttrs });
    if ($$self.$$.dirty & /*$content*/
    32) {
      $: $$invalidate(2, builder = $content);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    20) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, content, attrs, $content, $$scope, slots, div_binding];
}
var Scroll_area_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance166, create_fragment166, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_content",
      options,
      id: create_fragment166.name
    });
  }
  get asChild() {
    throw new Error("<Scroll_area_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_content_default = Scroll_area_content;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-scrollbar-y.svelte
var file151 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-scrollbar-y.svelte";
var get_default_slot_changes_1125 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1125 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes164 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context164 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block135(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1125
  );
  let div_levels = [
    /*builder*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file151, 23, 1, 415);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1125
            ),
            get_default_slot_context_1125
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [dirty & /*builder*/
      4 && /*builder*/
      ctx2[2]]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block135.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block149(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context164
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes164
            ),
            get_default_slot_context164
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block149.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment167(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block149, create_else_block135];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment167.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance167($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $scrollbarY;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_scrollbar_y", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { scrollbarY }, getAttrs: getAttrs2 } = getCtx22();
  validate_store(scrollbarY, "scrollbarY");
  component_subscribe($$self, scrollbarY, (value) => $$invalidate(5, $scrollbarY = value));
  const bitsAttrs = getAttrs2("scrollbar-y");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx22,
    melt,
    asChild,
    el,
    scrollbarY,
    getAttrs: getAttrs2,
    bitsAttrs,
    attrs,
    builder,
    $scrollbarY
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(4, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    $: $$invalidate(4, attrs = { ...$$restProps, ...bitsAttrs });
    if ($$self.$$.dirty & /*$scrollbarY*/
    32) {
      $: $$invalidate(2, builder = $scrollbarY);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    20) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    scrollbarY,
    attrs,
    $scrollbarY,
    $$scope,
    slots,
    div_binding
  ];
}
var Scroll_area_scrollbar_y = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance167, create_fragment167, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_scrollbar_y",
      options,
      id: create_fragment167.name
    });
  }
  get asChild() {
    throw new Error("<Scroll_area_scrollbar_y>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area_scrollbar_y>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area_scrollbar_y>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area_scrollbar_y>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_scrollbar_y_default = Scroll_area_scrollbar_y;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-scrollbar-x.svelte
var file152 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-scrollbar-x.svelte";
var get_default_slot_changes_1126 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1126 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes165 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context165 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block136(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1126
  );
  let div_levels = [
    /*builder*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file152, 23, 1, 415);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1126
            ),
            get_default_slot_context_1126
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [dirty & /*builder*/
      4 && /*builder*/
      ctx2[2]]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block136.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block150(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context165
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes165
            ),
            get_default_slot_context165
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block150.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment168(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block150, create_else_block136];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment168.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance168($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $scrollbarX;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_scrollbar_x", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { scrollbarX }, getAttrs: getAttrs2 } = getCtx22();
  validate_store(scrollbarX, "scrollbarX");
  component_subscribe($$self, scrollbarX, (value) => $$invalidate(5, $scrollbarX = value));
  const bitsAttrs = getAttrs2("scrollbar-x");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx22,
    melt,
    asChild,
    el,
    scrollbarX,
    getAttrs: getAttrs2,
    bitsAttrs,
    attrs,
    builder,
    $scrollbarX
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(4, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    $: $$invalidate(4, attrs = { ...$$restProps, ...bitsAttrs });
    if ($$self.$$.dirty & /*$scrollbarX*/
    32) {
      $: $$invalidate(2, builder = $scrollbarX);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    20) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    scrollbarX,
    attrs,
    $scrollbarX,
    $$scope,
    slots,
    div_binding
  ];
}
var Scroll_area_scrollbar_x = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance168, create_fragment168, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_scrollbar_x",
      options,
      id: create_fragment168.name
    });
  }
  get asChild() {
    throw new Error("<Scroll_area_scrollbar_x>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area_scrollbar_x>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area_scrollbar_x>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area_scrollbar_x>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_scrollbar_x_default = Scroll_area_scrollbar_x;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-scrollbar.svelte
var get_default_slot_changes_1127 = (dirty) => ({ builder: dirty & /*builder*/
64 });
var get_default_slot_context_1127 = (ctx) => ({ builder: (
  /*builder*/
  ctx[6]
) });
var get_default_slot_changes166 = (dirty) => ({ builder: dirty & /*builder*/
64 });
var get_default_slot_context166 = (ctx) => ({ builder: (
  /*builder*/
  ctx[6]
) });
function create_else_block137(ctx) {
  let scrollareascrollbarx;
  let current;
  const scrollareascrollbarx_spread_levels = [
    /*$$restProps*/
    ctx[2]
  ];
  let scrollareascrollbarx_props = {
    $$slots: {
      default: [
        create_default_slot_1,
        ({ builder }) => ({ 6: builder }),
        ({ builder }) => builder ? 64 : 0
      ]
    },
    $$scope: { ctx }
  };
  for (let i = 0; i < scrollareascrollbarx_spread_levels.length; i += 1) {
    scrollareascrollbarx_props = assign(scrollareascrollbarx_props, scrollareascrollbarx_spread_levels[i]);
  }
  scrollareascrollbarx = new scroll_area_scrollbar_x_default({
    props: scrollareascrollbarx_props,
    $$inline: true
  });
  const block = {
    c: function create() {
      create_component(scrollareascrollbarx.$$.fragment);
    },
    l: function claim(nodes) {
      claim_component(scrollareascrollbarx.$$.fragment, nodes);
    },
    m: function mount(target, anchor) {
      mount_component(scrollareascrollbarx, target, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      const scrollareascrollbarx_changes = dirty & /*$$restProps*/
      4 ? get_spread_update(scrollareascrollbarx_spread_levels, [get_spread_object(
        /*$$restProps*/
        ctx2[2]
      )]) : {};
      if (dirty & /*$$scope, builder*/
      96) {
        scrollareascrollbarx_changes.$$scope = { dirty, ctx: ctx2 };
      }
      scrollareascrollbarx.$set(scrollareascrollbarx_changes);
    },
    i: function intro(local) {
      if (current) return;
      transition_in(scrollareascrollbarx.$$.fragment, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(scrollareascrollbarx.$$.fragment, local);
      current = false;
    },
    d: function destroy(detaching) {
      destroy_component(scrollareascrollbarx, detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block137.name,
    type: "else",
    source: "(16:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block151(ctx) {
  let scrollareascrollbary;
  let current;
  const scrollareascrollbary_spread_levels = [
    /*$$restProps*/
    ctx[2]
  ];
  let scrollareascrollbary_props = {
    $$slots: {
      default: [
        create_default_slot,
        ({ builder }) => ({ 6: builder }),
        ({ builder }) => builder ? 64 : 0
      ]
    },
    $$scope: { ctx }
  };
  for (let i = 0; i < scrollareascrollbary_spread_levels.length; i += 1) {
    scrollareascrollbary_props = assign(scrollareascrollbary_props, scrollareascrollbary_spread_levels[i]);
  }
  scrollareascrollbary = new scroll_area_scrollbar_y_default({
    props: scrollareascrollbary_props,
    $$inline: true
  });
  const block = {
    c: function create() {
      create_component(scrollareascrollbary.$$.fragment);
    },
    l: function claim(nodes) {
      claim_component(scrollareascrollbary.$$.fragment, nodes);
    },
    m: function mount(target, anchor) {
      mount_component(scrollareascrollbary, target, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      const scrollareascrollbary_changes = dirty & /*$$restProps*/
      4 ? get_spread_update(scrollareascrollbary_spread_levels, [get_spread_object(
        /*$$restProps*/
        ctx2[2]
      )]) : {};
      if (dirty & /*$$scope, builder*/
      96) {
        scrollareascrollbary_changes.$$scope = { dirty, ctx: ctx2 };
      }
      scrollareascrollbary.$set(scrollareascrollbary_changes);
    },
    i: function intro(local) {
      if (current) return;
      transition_in(scrollareascrollbary.$$.fragment, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(scrollareascrollbary.$$.fragment, local);
      current = false;
    },
    d: function destroy(detaching) {
      destroy_component(scrollareascrollbary, detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block151.name,
    type: "if",
    source: '(12:0) {#if $orientationStore === \\"vertical\\"}',
    ctx
  });
  return block;
}
function create_default_slot_1(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[4].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[5],
    get_default_slot_context_1127
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        96)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[5],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[5]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[5],
              dirty,
              get_default_slot_changes_1127
            ),
            get_default_slot_context_1127
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_default_slot_1.name,
    type: "slot",
    source: "(17:1) <ScrollAreaScrollbarX {...$$restProps} let:builder>",
    ctx
  });
  return block;
}
function create_default_slot(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[4].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[5],
    get_default_slot_context166
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        96)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[5],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[5]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[5],
              dirty,
              get_default_slot_changes166
            ),
            get_default_slot_context166
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_default_slot.name,
    type: "slot",
    source: "(13:1) <ScrollAreaScrollbarY {...$$restProps} let:builder>",
    ctx
  });
  return block;
}
function create_fragment169(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block151, create_else_block137];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*$orientationStore*/
      ctx2[0] === "vertical"
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment169.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance169($$self, $$props, $$invalidate) {
  const omit_props_names = ["orientation"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $orientationStore;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_scrollbar", slots, ["default"]);
  let { orientation } = $$props;
  const orientationStore = writable(orientation);
  validate_store(orientationStore, "orientationStore");
  component_subscribe($$self, orientationStore, (value) => $$invalidate(0, $orientationStore = value));
  setScrollbarOrientation(orientationStore);
  $$self.$$.on_mount.push(function() {
    if (orientation === void 0 && !("orientation" in $$props || $$self.$$.bound[$$self.$$.props["orientation"]])) {
      console.warn("<Scroll_area_scrollbar> was created without expected prop 'orientation'");
    }
  });
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("orientation" in $$new_props) $$invalidate(3, orientation = $$new_props.orientation);
    if ("$$scope" in $$new_props) $$invalidate(5, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    setScrollbarOrientation,
    writable,
    ScrollAreaScrollbarY: scroll_area_scrollbar_y_default,
    ScrollAreaScrollbarX: scroll_area_scrollbar_x_default,
    orientation,
    orientationStore,
    $orientationStore
  });
  $$self.$inject_state = ($$new_props) => {
    if ("orientation" in $$props) $$invalidate(3, orientation = $$new_props.orientation);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*orientation*/
    8) {
      $: orientationStore.set(orientation);
    }
  };
  return [$orientationStore, orientationStore, $$restProps, orientation, slots, $$scope];
}
var Scroll_area_scrollbar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance169, create_fragment169, safe_not_equal, { orientation: 3 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_scrollbar",
      options,
      id: create_fragment169.name
    });
  }
  get orientation() {
    throw new Error("<Scroll_area_scrollbar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set orientation(value) {
    throw new Error("<Scroll_area_scrollbar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_scrollbar_default = Scroll_area_scrollbar;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-thumb-y.svelte
var file153 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-thumb-y.svelte";
var get_default_slot_changes_1128 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1128 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes167 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context167 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block138(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1128
  );
  let div_levels = [
    /*builder*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file153, 23, 1, 403);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1128
            ),
            get_default_slot_context_1128
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [dirty & /*builder*/
      4 && /*builder*/
      ctx2[2]]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block138.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block152(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context167
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes167
            ),
            get_default_slot_context167
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block152.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment170(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block152, create_else_block138];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment170.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance170($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $thumbY;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_thumb_y", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { thumbY }, getAttrs: getAttrs2 } = getCtx22();
  validate_store(thumbY, "thumbY");
  component_subscribe($$self, thumbY, (value) => $$invalidate(5, $thumbY = value));
  const bitsAttrs = getAttrs2("thumb-y");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx22,
    melt,
    asChild,
    el,
    thumbY,
    getAttrs: getAttrs2,
    bitsAttrs,
    attrs,
    builder,
    $thumbY
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(4, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    $: $$invalidate(4, attrs = { ...$$restProps, ...bitsAttrs });
    if ($$self.$$.dirty & /*$thumbY*/
    32) {
      $: $$invalidate(2, builder = $thumbY);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    20) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, thumbY, attrs, $thumbY, $$scope, slots, div_binding];
}
var Scroll_area_thumb_y = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance170, create_fragment170, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_thumb_y",
      options,
      id: create_fragment170.name
    });
  }
  get asChild() {
    throw new Error("<Scroll_area_thumb_y>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area_thumb_y>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area_thumb_y>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area_thumb_y>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_thumb_y_default = Scroll_area_thumb_y;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-thumb-x.svelte
var file154 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-thumb-x.svelte";
var get_default_slot_changes_1129 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1129 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes168 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context168 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block139(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1129
  );
  let div_levels = [
    /*builder*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file154, 23, 1, 403);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1129
            ),
            get_default_slot_context_1129
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [dirty & /*builder*/
      4 && /*builder*/
      ctx2[2]]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block139.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block153(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context168
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes168
            ),
            get_default_slot_context168
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block153.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment171(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block153, create_else_block139];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment171.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance171($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $thumbX;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_thumb_x", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { thumbX }, getAttrs: getAttrs2 } = getCtx22();
  validate_store(thumbX, "thumbX");
  component_subscribe($$self, thumbX, (value) => $$invalidate(5, $thumbX = value));
  const bitsAttrs = getAttrs2("thumb-x");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx22,
    melt,
    asChild,
    el,
    thumbX,
    getAttrs: getAttrs2,
    bitsAttrs,
    attrs,
    builder,
    $thumbX
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(4, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    $: $$invalidate(4, attrs = { ...$$restProps, ...bitsAttrs });
    if ($$self.$$.dirty & /*$thumbX*/
    32) {
      $: $$invalidate(2, builder = $thumbX);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    20) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, thumbX, attrs, $thumbX, $$scope, slots, div_binding];
}
var Scroll_area_thumb_x = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance171, create_fragment171, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_thumb_x",
      options,
      id: create_fragment171.name
    });
  }
  get asChild() {
    throw new Error("<Scroll_area_thumb_x>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area_thumb_x>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area_thumb_x>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area_thumb_x>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_thumb_x_default = Scroll_area_thumb_x;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-thumb.svelte
var get_default_slot_changes_1130 = (dirty) => ({ builder: dirty & /*builder*/
32 });
var get_default_slot_context_1130 = (ctx) => ({ builder: (
  /*builder*/
  ctx[5]
) });
var get_default_slot_changes169 = (dirty) => ({ builder: dirty & /*builder*/
32 });
var get_default_slot_context169 = (ctx) => ({ builder: (
  /*builder*/
  ctx[5]
) });
function create_else_block140(ctx) {
  let scrollareathumbx;
  let current;
  const scrollareathumbx_spread_levels = [
    /*$$restProps*/
    ctx[2]
  ];
  let scrollareathumbx_props = {
    $$slots: {
      default: [
        create_default_slot_12,
        ({ builder }) => ({ 5: builder }),
        ({ builder }) => builder ? 32 : 0
      ]
    },
    $$scope: { ctx }
  };
  for (let i = 0; i < scrollareathumbx_spread_levels.length; i += 1) {
    scrollareathumbx_props = assign(scrollareathumbx_props, scrollareathumbx_spread_levels[i]);
  }
  scrollareathumbx = new scroll_area_thumb_x_default({
    props: scrollareathumbx_props,
    $$inline: true
  });
  const block = {
    c: function create() {
      create_component(scrollareathumbx.$$.fragment);
    },
    l: function claim(nodes) {
      claim_component(scrollareathumbx.$$.fragment, nodes);
    },
    m: function mount(target, anchor) {
      mount_component(scrollareathumbx, target, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      const scrollareathumbx_changes = dirty & /*$$restProps*/
      4 ? get_spread_update(scrollareathumbx_spread_levels, [get_spread_object(
        /*$$restProps*/
        ctx2[2]
      )]) : {};
      if (dirty & /*$$scope, builder*/
      48) {
        scrollareathumbx_changes.$$scope = { dirty, ctx: ctx2 };
      }
      scrollareathumbx.$set(scrollareathumbx_changes);
    },
    i: function intro(local) {
      if (current) return;
      transition_in(scrollareathumbx.$$.fragment, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(scrollareathumbx.$$.fragment, local);
      current = false;
    },
    d: function destroy(detaching) {
      destroy_component(scrollareathumbx, detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block140.name,
    type: "else",
    source: "(11:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block154(ctx) {
  let scrollareathumby;
  let current;
  const scrollareathumby_spread_levels = [
    /*$$restProps*/
    ctx[2]
  ];
  let scrollareathumby_props = {
    $$slots: {
      default: [
        create_default_slot2,
        ({ builder }) => ({ 5: builder }),
        ({ builder }) => builder ? 32 : 0
      ]
    },
    $$scope: { ctx }
  };
  for (let i = 0; i < scrollareathumby_spread_levels.length; i += 1) {
    scrollareathumby_props = assign(scrollareathumby_props, scrollareathumby_spread_levels[i]);
  }
  scrollareathumby = new scroll_area_thumb_y_default({
    props: scrollareathumby_props,
    $$inline: true
  });
  const block = {
    c: function create() {
      create_component(scrollareathumby.$$.fragment);
    },
    l: function claim(nodes) {
      claim_component(scrollareathumby.$$.fragment, nodes);
    },
    m: function mount(target, anchor) {
      mount_component(scrollareathumby, target, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      const scrollareathumby_changes = dirty & /*$$restProps*/
      4 ? get_spread_update(scrollareathumby_spread_levels, [get_spread_object(
        /*$$restProps*/
        ctx2[2]
      )]) : {};
      if (dirty & /*$$scope, builder*/
      48) {
        scrollareathumby_changes.$$scope = { dirty, ctx: ctx2 };
      }
      scrollareathumby.$set(scrollareathumby_changes);
    },
    i: function intro(local) {
      if (current) return;
      transition_in(scrollareathumby.$$.fragment, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(scrollareathumby.$$.fragment, local);
      current = false;
    },
    d: function destroy(detaching) {
      destroy_component(scrollareathumby, detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block154.name,
    type: "if",
    source: '(7:0) {#if $orientation === \\"vertical\\"}',
    ctx
  });
  return block;
}
function create_default_slot_12(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[3].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context_1130
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        48)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes_1130
            ),
            get_default_slot_context_1130
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_default_slot_12.name,
    type: "slot",
    source: "(12:1) <ScrollAreaThumbX {...$$restProps} let:builder>",
    ctx
  });
  return block;
}
function create_default_slot2(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[3].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[4],
    get_default_slot_context169
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        48)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[4],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[4]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[4],
              dirty,
              get_default_slot_changes169
            ),
            get_default_slot_context169
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_default_slot2.name,
    type: "slot",
    source: "(8:1) <ScrollAreaThumbY {...$$restProps} let:builder>",
    ctx
  });
  return block;
}
function create_fragment172(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block154, create_else_block140];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*$orientation*/
      ctx2[0] === "vertical"
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment172.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance172($$self, $$props, $$invalidate) {
  const omit_props_names = [];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $orientation;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_thumb", slots, ["default"]);
  const orientation = getScrollbarOrientation();
  validate_store(orientation, "orientation");
  component_subscribe($$self, orientation, (value) => $$invalidate(0, $orientation = value));
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(2, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("$$scope" in $$new_props) $$invalidate(4, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getScrollbarOrientation,
    ScrollAreaThumbY: scroll_area_thumb_y_default,
    ScrollAreaThumbX: scroll_area_thumb_x_default,
    orientation,
    $orientation
  });
  return [$orientation, orientation, $$restProps, slots, $$scope];
}
var Scroll_area_thumb = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance172, create_fragment172, safe_not_equal, {});
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_thumb",
      options,
      id: create_fragment172.name
    });
  }
};
var scroll_area_thumb_default = Scroll_area_thumb;

// node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-corner.svelte
var file155 = "node_modules/bits-ui/dist/bits/scroll-area/components/scroll-area-corner.svelte";
var get_default_slot_changes_1131 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1131 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes170 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context170 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block141(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1131
  );
  let div_levels = [
    /*builder*/
    ctx[2]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file155, 23, 1, 402);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1131
            ),
            get_default_slot_context_1131
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [dirty & /*builder*/
      4 && /*builder*/
      ctx2[2]]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block141.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block155(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context170
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes170
            ),
            get_default_slot_context170
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block155.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment173(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block155, create_else_block141];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment173.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance173($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $corner;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Scroll_area_corner", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { corner }, getAttrs: getAttrs2 } = getCtx22();
  validate_store(corner, "corner");
  component_subscribe($$self, corner, (value) => $$invalidate(5, $corner = value));
  const bitsAttrs = getAttrs2("corner");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx22,
    melt,
    asChild,
    el,
    corner,
    getAttrs: getAttrs2,
    bitsAttrs,
    attrs,
    builder,
    $corner
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(4, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    $: $$invalidate(4, attrs = { ...$$restProps, ...bitsAttrs });
    if ($$self.$$.dirty & /*$corner*/
    32) {
      $: $$invalidate(2, builder = $corner);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    20) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, corner, attrs, $corner, $$scope, slots, div_binding];
}
var Scroll_area_corner = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance173, create_fragment173, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Scroll_area_corner",
      options,
      id: create_fragment173.name
    });
  }
  get asChild() {
    throw new Error("<Scroll_area_corner>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Scroll_area_corner>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Scroll_area_corner>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Scroll_area_corner>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var scroll_area_corner_default = Scroll_area_corner;

// node_modules/bits-ui/dist/bits/select/index.js
var select_exports = {};
__export(select_exports, {
  Arrow: () => select_arrow_default,
  Content: () => select_content_default,
  Group: () => select_group_default,
  Input: () => select_input_default,
  Item: () => select_item_default,
  ItemIndicator: () => select_item_indicator_default,
  Label: () => select_label_default,
  Root: () => select_default,
  Separator: () => separator_default,
  Trigger: () => select_trigger_default,
  Value: () => select_value_default
});

// node_modules/bits-ui/dist/bits/select/ctx.js
function getSelectData2() {
  const NAME = "select";
  const GROUP_NAME = "select-group";
  const ITEM_NAME = "select-item";
  const PARTS = [
    "arrow",
    "content",
    "group",
    "item",
    "indicator",
    "input",
    "label",
    "trigger",
    "value"
  ];
  return {
    NAME,
    GROUP_NAME,
    ITEM_NAME,
    PARTS
  };
}
function getCtx23() {
  const { NAME } = getSelectData2();
  return getContext(NAME);
}
function setCtx25(props) {
  const { NAME, PARTS } = getSelectData2();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const select = {
    ...createSelect({ ...removeUndefined2(props), forceVisible: true }),
    getAttrs: getAttrs2
  };
  setContext(NAME, select);
  return {
    ...select,
    updateOption: getOptionUpdater(select.options)
  };
}
function setGroupCtx3() {
  const { GROUP_NAME } = getSelectData2();
  const id = generateId2();
  setContext(GROUP_NAME, id);
  const { elements: { group }, getAttrs: getAttrs2 } = getCtx23();
  return { group, id, getAttrs: getAttrs2 };
}
function setItemCtx3(value) {
  const { ITEM_NAME } = getSelectData2();
  const select = getCtx23();
  setContext(ITEM_NAME, value);
  return select;
}
function getGroupLabel3() {
  const { GROUP_NAME } = getSelectData2();
  const id = getContext(GROUP_NAME);
  const { elements: { groupLabel }, getAttrs: getAttrs2 } = getCtx23();
  return { groupLabel, id, getAttrs: getAttrs2 };
}
function getItemIndicator2() {
  const { ITEM_NAME } = getSelectData2();
  const { helpers: { isSelected }, getAttrs: getAttrs2 } = getCtx23();
  const value = getContext(ITEM_NAME);
  return {
    value,
    isSelected,
    getAttrs: getAttrs2
  };
}
function setArrow5(size3 = 8) {
  var _a;
  const select = getCtx23();
  (_a = select.options.arrowSize) == null ? void 0 : _a.set(size3);
  return select;
}
function updatePositioning9(props) {
  const defaultPlacement = {
    side: "bottom",
    align: "center",
    sameWidth: true
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx23();
  const updater = getPositioningUpdater(positioning);
  updater(withDefaults);
}

// node_modules/bits-ui/dist/bits/select/components/select.svelte
var get_default_slot_changes171 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context171 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment174(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[18].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[17],
    get_default_slot_context171
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        131073)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[17],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[17]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[17],
              dirty,
              get_default_slot_changes171
            ),
            get_default_slot_context171
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment174.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance174($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select", slots, ["default"]);
  let { required = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { preventScroll = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { closeOnEscape = void 0 } = $$props;
  let { closeOnOutsideClick = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { name: name27 = void 0 } = $$props;
  let { multiple = false } = $$props;
  let { selected = void 0 } = $$props;
  let { onSelectedChange = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { items = [] } = $$props;
  let { onOutsideClick = void 0 } = $$props;
  const { states: { open: localOpen, selected: localSelected }, updateOption, ids } = setCtx25({
    required,
    disabled,
    preventScroll,
    loop,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    name: name27,
    onOutsideClick,
    multiple,
    forceVisible: true,
    defaultSelected: Array.isArray(selected) ? [...selected] : (
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      selected
    ),
    defaultOpen: open,
    onSelectedChange: ({ next: next2 }) => {
      if (Array.isArray(next2)) {
        if (!Array.isArray(selected) || !arraysAreEqual(selected, next2)) {
          onSelectedChange == null ? void 0 : onSelectedChange(next2);
          $$invalidate(2, selected = next2);
          return next2;
        }
        return next2;
      }
      if (selected !== next2) {
        onSelectedChange == null ? void 0 : onSelectedChange(next2);
        $$invalidate(2, selected = next2);
      }
      return next2;
    },
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(3, open = next2);
      }
      return next2;
    },
    items
  });
  const idValues = derived([ids.menu, ids.trigger, ids.label], ([$menuId, $triggerId, $labelId]) => ({
    menu: $menuId,
    trigger: $triggerId,
    label: $labelId
  }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "required",
    "disabled",
    "preventScroll",
    "loop",
    "closeOnEscape",
    "closeOnOutsideClick",
    "portal",
    "name",
    "multiple",
    "selected",
    "onSelectedChange",
    "open",
    "onOpenChange",
    "items",
    "onOutsideClick"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Select> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("required" in $$props2) $$invalidate(4, required = $$props2.required);
    if ("disabled" in $$props2) $$invalidate(5, disabled = $$props2.disabled);
    if ("preventScroll" in $$props2) $$invalidate(6, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(7, loop = $$props2.loop);
    if ("closeOnEscape" in $$props2) $$invalidate(8, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(9, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(10, portal = $$props2.portal);
    if ("name" in $$props2) $$invalidate(11, name27 = $$props2.name);
    if ("multiple" in $$props2) $$invalidate(12, multiple = $$props2.multiple);
    if ("selected" in $$props2) $$invalidate(2, selected = $$props2.selected);
    if ("onSelectedChange" in $$props2) $$invalidate(13, onSelectedChange = $$props2.onSelectedChange);
    if ("open" in $$props2) $$invalidate(3, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(14, onOpenChange = $$props2.onOpenChange);
    if ("items" in $$props2) $$invalidate(15, items = $$props2.items);
    if ("onOutsideClick" in $$props2) $$invalidate(16, onOutsideClick = $$props2.onOutsideClick);
    if ("$$scope" in $$props2) $$invalidate(17, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    arraysAreEqual,
    derived,
    setCtx: setCtx25,
    required,
    disabled,
    preventScroll,
    loop,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    name: name27,
    multiple,
    selected,
    onSelectedChange,
    open,
    onOpenChange,
    items,
    onOutsideClick,
    localOpen,
    localSelected,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("required" in $$props2) $$invalidate(4, required = $$props2.required);
    if ("disabled" in $$props2) $$invalidate(5, disabled = $$props2.disabled);
    if ("preventScroll" in $$props2) $$invalidate(6, preventScroll = $$props2.preventScroll);
    if ("loop" in $$props2) $$invalidate(7, loop = $$props2.loop);
    if ("closeOnEscape" in $$props2) $$invalidate(8, closeOnEscape = $$props2.closeOnEscape);
    if ("closeOnOutsideClick" in $$props2) $$invalidate(9, closeOnOutsideClick = $$props2.closeOnOutsideClick);
    if ("portal" in $$props2) $$invalidate(10, portal = $$props2.portal);
    if ("name" in $$props2) $$invalidate(11, name27 = $$props2.name);
    if ("multiple" in $$props2) $$invalidate(12, multiple = $$props2.multiple);
    if ("selected" in $$props2) $$invalidate(2, selected = $$props2.selected);
    if ("onSelectedChange" in $$props2) $$invalidate(13, onSelectedChange = $$props2.onSelectedChange);
    if ("open" in $$props2) $$invalidate(3, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(14, onOpenChange = $$props2.onOpenChange);
    if ("items" in $$props2) $$invalidate(15, items = $$props2.items);
    if ("onOutsideClick" in $$props2) $$invalidate(16, onOutsideClick = $$props2.onOutsideClick);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    8) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*selected*/
    4) {
      $: selected !== void 0 && localSelected.set(Array.isArray(selected) ? [...selected] : (
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        selected
      ));
    }
    if ($$self.$$.dirty & /*required*/
    16) {
      $: updateOption("required", required);
    }
    if ($$self.$$.dirty & /*disabled*/
    32) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*preventScroll*/
    64) {
      $: updateOption("preventScroll", preventScroll);
    }
    if ($$self.$$.dirty & /*loop*/
    128) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    256) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*closeOnOutsideClick*/
    512) {
      $: updateOption("closeOnOutsideClick", closeOnOutsideClick);
    }
    if ($$self.$$.dirty & /*portal*/
    1024) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*name*/
    2048) {
      $: updateOption("name", name27);
    }
    if ($$self.$$.dirty & /*multiple*/
    4096) {
      $: updateOption("multiple", multiple);
    }
    if ($$self.$$.dirty & /*onOutsideClick*/
    65536) {
      $: updateOption("onOutsideClick", onOutsideClick);
    }
  };
  return [
    $idValues,
    idValues,
    selected,
    open,
    required,
    disabled,
    preventScroll,
    loop,
    closeOnEscape,
    closeOnOutsideClick,
    portal,
    name27,
    multiple,
    onSelectedChange,
    onOpenChange,
    items,
    onOutsideClick,
    $$scope,
    slots
  ];
}
var Select = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance174, create_fragment174, safe_not_equal, {
      required: 4,
      disabled: 5,
      preventScroll: 6,
      loop: 7,
      closeOnEscape: 8,
      closeOnOutsideClick: 9,
      portal: 10,
      name: 11,
      multiple: 12,
      selected: 2,
      onSelectedChange: 13,
      open: 3,
      onOpenChange: 14,
      items: 15,
      onOutsideClick: 16
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select",
      options,
      id: create_fragment174.name
    });
  }
  get required() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set required(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get preventScroll() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set preventScroll(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnEscape() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnOutsideClick() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnOutsideClick(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get name() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set name(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get multiple() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set multiple(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get selected() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set selected(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onSelectedChange() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onSelectedChange(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get items() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set items(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOutsideClick() {
    throw new Error("<Select>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOutsideClick(value) {
    throw new Error("<Select>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_default = Select;

// node_modules/bits-ui/dist/bits/select/components/select-arrow.svelte
var file156 = "node_modules/bits-ui/dist/bits/select/components/select-arrow.svelte";
var get_default_slot_changes172 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context172 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block142(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file156, 19, 1, 367);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block142.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block156(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context172
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes172
            ),
            get_default_slot_context172
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block156.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment175(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block156, create_else_block142];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment175.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance175($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "size"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_arrow", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { size: size3 = 8 } = $$props;
  const { elements: { arrow: arrow3 }, getAttrs: getAttrs2 } = setArrow5(size3);
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getAttrs2("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setArrow: setArrow5,
    asChild,
    el,
    size: size3,
    arrow: arrow3,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Select_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance175, create_fragment175, safe_not_equal, { asChild: 1, el: 0, size: 5 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_arrow",
      options,
      id: create_fragment175.name
    });
  }
  get asChild() {
    throw new Error("<Select_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get size() {
    throw new Error("<Select_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Select_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_arrow_default = Select_arrow;

// node_modules/bits-ui/dist/bits/select/components/select-content.svelte
var file157 = "node_modules/bits-ui/dist/bits/select/components/select-content.svelte";
var get_default_slot_changes_513 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_513 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_413 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_413 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_313 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_313 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_213 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_213 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_1132 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_1132 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes173 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context173 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_515(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_513
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file157, 106, 1, 2431);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[38](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_4*/
            ctx[33],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes_513
            ),
            get_default_slot_context_513
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[38](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_515.name,
    type: "if",
    source: "(106:16) ",
    ctx
  });
  return block;
}
function create_if_block_415(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_413
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file157, 95, 1, 2220);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[37](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_3*/
            ctx[32],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_413
            ),
            get_default_slot_context_413
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[37](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_415.name,
    type: "if",
    source: "(95:33) ",
    ctx
  });
  return block;
}
function create_if_block_315(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_313
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file157, 84, 1, 1995);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[36](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_2*/
            ctx[31],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_313
            ),
            get_default_slot_context_313
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[36](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_315.name,
    type: "if",
    source: "(84:32) ",
    ctx
  });
  return block;
}
function create_if_block_215(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_213
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file157, 72, 1, 1729);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[35](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler_1*/
            ctx[30],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_213
            ),
            get_default_slot_context_213
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[35](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_215.name,
    type: "if",
    source: "(72:49) ",
    ctx
  });
  return block;
}
function create_if_block_119(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_1132
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file157, 61, 1, 1484);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[34](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerleave",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler*/
            ctx[29],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_1132
            ),
            get_default_slot_context_1132
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[34](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_119.name,
    type: "if",
    source: "(61:30) ",
    ctx
  });
  return block;
}
function create_if_block157(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context173
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes173
            ),
            get_default_slot_context173
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block157.name,
    type: "if",
    source: "(59:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment176(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block157,
    create_if_block_119,
    create_if_block_215,
    create_if_block_315,
    create_if_block_415,
    create_if_block_515
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment176.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance176($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $open;
  let $menu;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "bottom" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = true } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { menu }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx23();
  validate_store(menu, "menu");
  component_subscribe($$self, menu, (value) => $$invalidate(26, $menu = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("content");
  function keydown_handler(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_1(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_2(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_3(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler_4(event) {
    bubble.call(this, $$self, event);
  }
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(27, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    createDispatcher,
    melt,
    getCtx: getCtx23,
    updatePositioning: updatePositioning9,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    menu,
    open,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $open,
    $menu
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    16384) {
      $: if (id) {
        ids.menu.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$menu*/
    67108864) {
      $: $$invalidate(8, builder = $menu);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*$open, side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    67076608) {
      $: if ($open) {
        updatePositioning9({
          side,
          align,
          sideOffset,
          alignOffset,
          collisionPadding,
          avoidCollisions,
          collisionBoundary,
          sameWidth,
          fitViewport,
          strategy,
          overlap
        });
      }
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    menu,
    open,
    dispatch,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $menu,
    $$scope,
    slots,
    keydown_handler,
    keydown_handler_1,
    keydown_handler_2,
    keydown_handler_3,
    keydown_handler_4,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Select_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance176,
      create_fragment176,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 14,
        side: 15,
        align: 16,
        sideOffset: 17,
        alignOffset: 18,
        collisionPadding: 19,
        avoidCollisions: 20,
        collisionBoundary: 21,
        sameWidth: 22,
        fitViewport: 23,
        strategy: 24,
        overlap: 25,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_content",
      options,
      id: create_fragment176.name
    });
  }
  get transition() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_content_default = Select_content;

// node_modules/bits-ui/dist/bits/select/components/select-group.svelte
var file158 = "node_modules/bits-ui/dist/bits/select/components/select-group.svelte";
var get_default_slot_changes_1133 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1133 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes174 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context174 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block143(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1133
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file158, 15, 1, 338);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1133
            ),
            get_default_slot_context_1133
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block143.name,
    type: "else",
    source: "(15:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block158(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context174
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes174
            ),
            get_default_slot_context174
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block158.name,
    type: "if",
    source: "(13:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment177(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block158, create_else_block143];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment177.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance177($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $group;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_group", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { group, id, getAttrs: getAttrs2 } = setGroupCtx3();
  validate_store(group, "group");
  component_subscribe($$self, group, (value) => $$invalidate(5, $group = value));
  const attrs = getAttrs2("group");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setGroupCtx: setGroupCtx3,
    asChild,
    el,
    group,
    id,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $group
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$group*/
    32) {
      $: $$invalidate(2, builder = $group(id));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, group, $$restProps, $group, $$scope, slots, div_binding];
}
var Select_group = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance177, create_fragment177, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_group",
      options,
      id: create_fragment177.name
    });
  }
  get asChild() {
    throw new Error("<Select_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_group_default = Select_group;

// node_modules/bits-ui/dist/bits/select/components/select-input.svelte
var file159 = "node_modules/bits-ui/dist/bits/select/components/select-input.svelte";
var get_default_slot_changes175 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context175 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block144(ctx) {
  let input;
  let builder_action_action;
  let mounted;
  let dispose;
  let input_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let input_data = {};
  for (let i = 0; i < input_levels.length; i += 1) {
    input_data = assign(input_data, input_levels[i]);
  }
  const block = {
    c: function create() {
      input = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input = claim_element(nodes, "INPUT", {});
      this.h();
    },
    h: function hydrate() {
      set_attributes(input, input_data);
      add_location(input, file159, 23, 1, 428);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input, anchor);
      if (input.autofocus) input.focus();
      ctx[11](input);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(input));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(input, input_data = get_spread_update(input_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input);
      }
      ctx[11](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block144.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block159(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context175
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes175
            ),
            get_default_slot_context175
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block159.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment178(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block159, create_else_block144];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment178.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance178($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $hiddenInput;
  let $disabled;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_input", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { hiddenInput }, options: { disabled }, getAttrs: getAttrs2 } = getCtx23();
  validate_store(hiddenInput, "hiddenInput");
  component_subscribe($$self, hiddenInput, (value) => $$invalidate(7, $hiddenInput = value));
  validate_store(disabled, "disabled");
  component_subscribe($$self, disabled, (value) => $$invalidate(8, $disabled = value));
  function input_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx23,
    asChild,
    el,
    hiddenInput,
    disabled,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $hiddenInput,
    $disabled
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(6, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$disabled*/
    256) {
      $: $$invalidate(6, attrs = {
        ...getAttrs2("input"),
        disabled: $disabled ? true : void 0
      });
    }
    if ($$self.$$.dirty & /*$hiddenInput*/
    128) {
      $: $$invalidate(2, builder = $hiddenInput);
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    68) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    hiddenInput,
    disabled,
    $$restProps,
    attrs,
    $hiddenInput,
    $disabled,
    $$scope,
    slots,
    input_binding
  ];
}
var Select_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance178, create_fragment178, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_input",
      options,
      id: create_fragment178.name
    });
  }
  get asChild() {
    throw new Error("<Select_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_input_default = Select_input;

// node_modules/bits-ui/dist/bits/select/components/select-item.svelte
var file160 = "node_modules/bits-ui/dist/bits/select/components/select-item.svelte";
var get_default_slot_changes_1134 = (dirty) => ({
  builder: dirty & /*builder*/
  16,
  isSelected: dirty & /*isSelected*/
  32
});
var get_default_slot_context_1134 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[4]
  ),
  isSelected: (
    /*isSelected*/
    ctx[5]
  )
});
var get_default_slot_changes176 = (dirty) => ({
  builder: dirty & /*builder*/
  16,
  isSelected: dirty & /*isSelected*/
  32
});
var get_default_slot_context176 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[4]
  ),
  isSelected: (
    /*isSelected*/
    ctx[5]
  )
});
function create_else_block145(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[14].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[13],
    get_default_slot_context_1134
  );
  const default_slot_or_fallback = default_slot || fallback_block11(ctx);
  let div_levels = [
    /*builder*/
    ctx[4],
    /*$$restProps*/
    ctx[9]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot_or_fallback) default_slot_or_fallback.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot_or_fallback) default_slot_or_fallback.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file160, 28, 1, 747);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot_or_fallback) {
        default_slot_or_fallback.m(div, null);
      }
      ctx[19](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[4].action(div)),
          listen_dev(
            div,
            "m-click",
            /*dispatch*/
            ctx[8],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointermove",
            /*dispatch*/
            ctx[8],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "focusin",
            /*focusin_handler*/
            ctx[15],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "keydown",
            /*keydown_handler*/
            ctx[16],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "focusout",
            /*focusout_handler*/
            ctx[17],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "pointerleave",
            /*pointerleave_handler*/
            ctx[18],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, isSelected*/
        8240)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[13],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[13]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[13],
              dirty,
              get_default_slot_changes_1134
            ),
            get_default_slot_context_1134
          );
        }
      } else {
        if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*label, value*/
        6)) {
          default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        16 && /*builder*/
        ctx2[4],
        dirty & /*$$restProps*/
        512 && /*$$restProps*/
        ctx2[9]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot_or_fallback, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot_or_fallback, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot_or_fallback) default_slot_or_fallback.d(detaching);
      ctx[19](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block145.name,
    type: "else",
    source: "(28:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block160(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[14].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[13],
    get_default_slot_context176
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, isSelected*/
        8240)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[13],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[13]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[13],
              dirty,
              get_default_slot_changes176
            ),
            get_default_slot_context176
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block160.name,
    type: "if",
    source: "(26:0) {#if asChild}",
    ctx
  });
  return block;
}
function fallback_block11(ctx) {
  let t_value = (
    /*label*/
    (ctx[2] ? (
      /*label*/
      ctx[2]
    ) : (
      /*value*/
      ctx[1]
    )) + ""
  );
  let t;
  const block = {
    c: function create() {
      t = text(t_value);
    },
    l: function claim(nodes) {
      t = claim_text(nodes, t_value);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, t, anchor);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*label, value*/
      6 && t_value !== (t_value = /*label*/
      (ctx2[2] ? (
        /*label*/
        ctx2[2]
      ) : (
        /*value*/
        ctx2[1]
      )) + "")) set_data_dev(t, t_value);
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: fallback_block11.name,
    type: "fallback",
    source: "(40:31)     ",
    ctx
  });
  return block;
}
function create_fragment179(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block160, create_else_block145];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[3]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment179.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance179($$self, $$props, $$invalidate) {
  let builder;
  let isSelected;
  const omit_props_names = ["value", "disabled", "label", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isSelectedStore;
  let $item;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_item", slots, ["default"]);
  let { value } = $$props;
  let { disabled = void 0 } = $$props;
  let { label = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { option: item }, helpers: { isSelected: isSelectedStore }, getAttrs: getAttrs2 } = setItemCtx3(value);
  validate_store(item, "item");
  component_subscribe($$self, item, (value2) => $$invalidate(12, $item = value2));
  validate_store(isSelectedStore, "isSelectedStore");
  component_subscribe($$self, isSelectedStore, (value2) => $$invalidate(11, $isSelectedStore = value2));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("item");
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Select_item> was created without expected prop 'value'");
    }
  });
  function focusin_handler(event) {
    bubble.call(this, $$self, event);
  }
  function keydown_handler(event) {
    bubble.call(this, $$self, event);
  }
  function focusout_handler(event) {
    bubble.call(this, $$self, event);
  }
  function pointerleave_handler(event) {
    bubble.call(this, $$self, event);
  }
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(9, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(1, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("label" in $$new_props) $$invalidate(2, label = $$new_props.label);
    if ("asChild" in $$new_props) $$invalidate(3, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(13, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setItemCtx: setItemCtx3,
    createDispatcher,
    value,
    disabled,
    label,
    asChild,
    el,
    item,
    isSelectedStore,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    isSelected,
    builder,
    $isSelectedStore,
    $item
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(1, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("label" in $$props) $$invalidate(2, label = $$new_props.label);
    if ("asChild" in $$props) $$invalidate(3, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("isSelected" in $$props) $$invalidate(5, isSelected = $$new_props.isSelected);
    if ("builder" in $$props) $$invalidate(4, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$item, value, disabled, label*/
    5126) {
      $: $$invalidate(4, builder = $item({ value, disabled, label }));
    }
    if ($$self.$$.dirty & /*builder*/
    16) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty & /*$isSelectedStore, value*/
    2050) {
      $: $$invalidate(5, isSelected = $isSelectedStore(value));
    }
  };
  return [
    el,
    value,
    label,
    asChild,
    builder,
    isSelected,
    item,
    isSelectedStore,
    dispatch,
    $$restProps,
    disabled,
    $isSelectedStore,
    $item,
    $$scope,
    slots,
    focusin_handler,
    keydown_handler,
    focusout_handler,
    pointerleave_handler,
    div_binding
  ];
}
var Select_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance179, create_fragment179, safe_not_equal, {
      value: 1,
      disabled: 10,
      label: 2,
      asChild: 3,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_item",
      options,
      id: create_fragment179.name
    });
  }
  get value() {
    throw new Error("<Select_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Select_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Select_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Select_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get label() {
    throw new Error("<Select_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set label(value) {
    throw new Error("<Select_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Select_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_item_default = Select_item;

// node_modules/bits-ui/dist/bits/select/components/select-item-indicator.svelte
var file161 = "node_modules/bits-ui/dist/bits/select/components/select-item-indicator.svelte";
var get_default_slot_changes_1135 = (dirty) => ({ isSelected: dirty & /*$isSelected*/
4 });
var get_default_slot_context_1135 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[5]
  ),
  isSelected: (
    /*$isSelected*/
    ctx[2](
      /*value*/
      ctx[4]
    )
  )
});
var get_default_slot_changes177 = (dirty) => ({ isSelected: dirty & /*$isSelected*/
4 });
var get_default_slot_context177 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[5]
  ),
  isSelected: (
    /*$isSelected*/
    ctx[2](
      /*value*/
      ctx[4]
    )
  )
});
function create_else_block146(ctx) {
  let div;
  let show_if = (
    /*$isSelected*/
    ctx[2](
      /*value*/
      ctx[4]
    )
  );
  let current;
  let if_block = show_if && create_if_block_120(ctx);
  let div_levels = [
    /*$$restProps*/
    ctx[6],
    /*attrs*/
    ctx[5]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (if_block) if_block.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (if_block) if_block.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file161, 10, 1, 287);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (if_block) if_block.m(div, null);
      ctx[9](div);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*$isSelected*/
      4) show_if = /*$isSelected*/
      ctx2[2](
        /*value*/
        ctx2[4]
      );
      if (show_if) {
        if (if_block) {
          if_block.p(ctx2, dirty);
          if (dirty & /*$isSelected*/
          4) {
            transition_in(if_block, 1);
          }
        } else {
          if_block = create_if_block_120(ctx2);
          if_block.c();
          transition_in(if_block, 1);
          if_block.m(div, null);
        }
      } else if (if_block) {
        group_outros();
        transition_out(if_block, 1, 1, () => {
          if_block = null;
        });
        check_outros();
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6],
        /*attrs*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (if_block) if_block.d();
      ctx[9](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block146.name,
    type: "else",
    source: "(10:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block161(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context177
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $isSelected*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes177
            ),
            get_default_slot_context177
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block161.name,
    type: "if",
    source: "(8:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_if_block_120(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1135
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $isSelected*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1135
            ),
            get_default_slot_context_1135
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_120.name,
    type: "if",
    source: "(12:2) {#if $isSelected(value)}",
    ctx
  });
  return block;
}
function create_fragment180(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block161, create_else_block146];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment180.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance180($$self, $$props, $$invalidate) {
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $isSelected;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_item_indicator", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { isSelected, value, getAttrs: getAttrs2 } = getItemIndicator2();
  validate_store(isSelected, "isSelected");
  component_subscribe($$self, isSelected, (value2) => $$invalidate(2, $isSelected = value2));
  const attrs = getAttrs2("indicator");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getItemIndicator: getItemIndicator2,
    asChild,
    el,
    isSelected,
    value,
    getAttrs: getAttrs2,
    attrs,
    $isSelected
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  return [
    el,
    asChild,
    $isSelected,
    isSelected,
    value,
    attrs,
    $$restProps,
    $$scope,
    slots,
    div_binding
  ];
}
var Select_item_indicator = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance180, create_fragment180, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_item_indicator",
      options,
      id: create_fragment180.name
    });
  }
  get asChild() {
    throw new Error("<Select_item_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_item_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_item_indicator>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_item_indicator>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_item_indicator_default = Select_item_indicator;

// node_modules/bits-ui/dist/bits/select/components/select-label.svelte
var file162 = "node_modules/bits-ui/dist/bits/select/components/select-label.svelte";
var get_default_slot_changes_1136 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1136 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes178 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context178 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block147(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1136
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file162, 21, 1, 466);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[9](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1136
            ),
            get_default_slot_context_1136
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block147.name,
    type: "else",
    source: "(21:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block162(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context178
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes178
            ),
            get_default_slot_context178
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block162.name,
    type: "if",
    source: "(19:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment181(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block162, create_else_block147];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment181.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance181($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $groupLabel;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_label", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { ids, getAttrs: getAttrs2 } = getCtx23();
  const { groupLabel, id: groupId } = getGroupLabel3();
  validate_store(groupLabel, "groupLabel");
  component_subscribe($$self, groupLabel, (value) => $$invalidate(6, $groupLabel = value));
  const attrs = getAttrs2("label");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getGroupLabel: getGroupLabel3,
    getCtx: getCtx23,
    asChild,
    id,
    el,
    ids,
    getAttrs: getAttrs2,
    groupLabel,
    groupId,
    attrs,
    builder,
    $groupLabel
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(5, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    32) {
      $: if (id) {
        ids.label.set(id);
      }
    }
    if ($$self.$$.dirty & /*$groupLabel*/
    64) {
      $: $$invalidate(2, builder = $groupLabel(groupId));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    groupLabel,
    $$restProps,
    id,
    $groupLabel,
    $$scope,
    slots,
    div_binding
  ];
}
var Select_label = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance181, create_fragment181, safe_not_equal, { asChild: 1, id: 5, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_label",
      options,
      id: create_fragment181.name
    });
  }
  get asChild() {
    throw new Error("<Select_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Select_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Select_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_label>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_label>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_label_default = Select_label;

// node_modules/bits-ui/dist/bits/select/components/select-trigger.svelte
var file163 = "node_modules/bits-ui/dist/bits/select/components/select-trigger.svelte";
var get_default_slot_changes_1137 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1137 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes179 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context179 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block148(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_1137
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file163, 26, 1, 520);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[10](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_1137
            ),
            get_default_slot_context_1137
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block148.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block163(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context179
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes179
            ),
            get_default_slot_context179
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block163.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment182(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block163, create_else_block148];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment182.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance182($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getAttrs: getAttrs2 } = getCtx23();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(7, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx23,
    createDispatcher,
    asChild,
    id,
    el,
    trigger,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    128) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Select_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance182, create_fragment182, safe_not_equal, { asChild: 1, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_trigger",
      options,
      id: create_fragment182.name
    });
  }
  get asChild() {
    throw new Error("<Select_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Select_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Select_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_trigger_default = Select_trigger;

// node_modules/bits-ui/dist/bits/select/components/select-value.svelte
var file164 = "node_modules/bits-ui/dist/bits/select/components/select-value.svelte";
var get_default_slot_changes180 = (dirty) => ({ label: dirty & /*label*/
8 });
var get_default_slot_context180 = (ctx) => ({
  label: (
    /*label*/
    ctx[3]
  ),
  attrs: (
    /*attrs*/
    ctx[5]
  )
});
function create_else_block149(ctx) {
  let span;
  let t_value = (
    /*label*/
    (ctx[3] ? (
      /*label*/
      ctx[3]
    ) : (
      /*placeholder*/
      ctx[1]
    )) + ""
  );
  let t;
  let span_data_placeholder_value;
  let span_levels = [
    /*$$restProps*/
    ctx[6],
    /*attrs*/
    ctx[5],
    {
      "data-placeholder": span_data_placeholder_value = !/*label*/
      ctx[3] ? "" : void 0
    }
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      t = text(t_value);
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", { "data-placeholder": true });
      var span_nodes = children(span);
      t = claim_text(span_nodes, t_value);
      span_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file164, 16, 1, 309);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      append_hydration_dev(span, t);
      ctx[10](span);
    },
    p: function update(ctx2, dirty) {
      if (dirty & /*label, placeholder*/
      10 && t_value !== (t_value = /*label*/
      (ctx2[3] ? (
        /*label*/
        ctx2[3]
      ) : (
        /*placeholder*/
        ctx2[1]
      )) + "")) set_data_maybe_contenteditable_dev(t, t_value, span_data["contenteditable"]);
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6],
        /*attrs*/
        ctx2[5],
        dirty & /*label*/
        8 && span_data_placeholder_value !== (span_data_placeholder_value = !/*label*/
        ctx2[3] ? "" : void 0) && {
          "data-placeholder": span_data_placeholder_value
        }
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      ctx[10](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block149.name,
    type: "else",
    source: "(16:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block164(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context180
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, label*/
        264)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes180
            ),
            get_default_slot_context180
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block164.name,
    type: "if",
    source: "(14:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment183(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block164, create_else_block149];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment183.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance183($$self, $$props, $$invalidate) {
  let label;
  const omit_props_names = ["placeholder", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $selectedLabel;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Select_value", slots, ["default"]);
  let { placeholder = "" } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { states: { selectedLabel }, getAttrs: getAttrs2 } = getCtx23();
  validate_store(selectedLabel, "selectedLabel");
  component_subscribe($$self, selectedLabel, (value) => $$invalidate(7, $selectedLabel = value));
  const attrs = getAttrs2("value");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("placeholder" in $$new_props) $$invalidate(1, placeholder = $$new_props.placeholder);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx23,
    placeholder,
    asChild,
    el,
    selectedLabel,
    getAttrs: getAttrs2,
    attrs,
    label,
    $selectedLabel
  });
  $$self.$inject_state = ($$new_props) => {
    if ("placeholder" in $$props) $$invalidate(1, placeholder = $$new_props.placeholder);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("label" in $$props) $$invalidate(3, label = $$new_props.label);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$selectedLabel*/
    128) {
      $: $$invalidate(3, label = $selectedLabel);
    }
  };
  return [
    el,
    placeholder,
    asChild,
    label,
    selectedLabel,
    attrs,
    $$restProps,
    $selectedLabel,
    $$scope,
    slots,
    span_binding
  ];
}
var Select_value = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance183, create_fragment183, safe_not_equal, { placeholder: 1, asChild: 2, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Select_value",
      options,
      id: create_fragment183.name
    });
  }
  get placeholder() {
    throw new Error("<Select_value>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set placeholder(value) {
    throw new Error("<Select_value>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Select_value>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Select_value>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Select_value>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Select_value>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var select_value_default = Select_value;

// node_modules/bits-ui/dist/bits/separator/index.js
var separator_exports = {};
__export(separator_exports, {
  Root: () => separator_default
});

// node_modules/bits-ui/dist/bits/slider/index.js
var slider_exports = {};
__export(slider_exports, {
  Input: () => slider_input_default,
  Range: () => slider_range_default,
  Root: () => slider_default,
  Thumb: () => slider_thumb_default,
  Tick: () => slider_tick_default
});

// node_modules/bits-ui/dist/bits/slider/ctx.js
function getSliderData() {
  const NAME = "slider";
  const PARTS = ["root", "input", "range", "thumb", "tick"];
  return {
    NAME,
    PARTS
  };
}
function setCtx26(props) {
  const { NAME, PARTS } = getSliderData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const slider = { ...createSlider(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, slider);
  return {
    ...slider,
    updateOption: getOptionUpdater(slider.options)
  };
}
function getCtx24() {
  const { NAME } = getSliderData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/slider/components/slider.svelte
var file165 = "node_modules/bits-ui/dist/bits/slider/components/slider.svelte";
var get_default_slot_changes_1138 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  ticks: dirty & /*$ticks*/
  8,
  thumbs: dirty & /*$thumbs*/
  16
});
var get_default_slot_context_1138 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  ticks: (
    /*$ticks*/
    ctx[3]
  ),
  thumbs: (
    /*$thumbs*/
    ctx[4]
  )
});
var get_default_slot_changes181 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  ticks: dirty & /*$ticks*/
  8,
  thumbs: dirty & /*$thumbs*/
  16
});
var get_default_slot_context181 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  ticks: (
    /*$ticks*/
    ctx[3]
  ),
  thumbs: (
    /*$thumbs*/
    ctx[4]
  )
});
function create_else_block150(ctx) {
  let span;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[18].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[17],
    get_default_slot_context_1138
  );
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[8]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      var span_nodes = children(span);
      if (default_slot) default_slot.l(span_nodes);
      span_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file165, 53, 1, 1073);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      if (default_slot) {
        default_slot.m(span, null);
      }
      ctx[19](span);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $ticks, $thumbs*/
        131100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[17],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[17]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[17],
              dirty,
              get_default_slot_changes_1138
            ),
            get_default_slot_context_1138
          );
        }
      }
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        256 && /*$$restProps*/
        ctx2[8]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[19](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block150.name,
    type: "else",
    source: "(53:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block165(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[18].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[17],
    get_default_slot_context181
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $ticks, $thumbs*/
        131100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[17],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[17]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[17],
              dirty,
              get_default_slot_changes181
            ),
            get_default_slot_context181
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block165.name,
    type: "if",
    source: "(51:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment184(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block165, create_else_block150];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment184.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance184($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "disabled",
    "min",
    "max",
    "step",
    "orientation",
    "value",
    "onValueChange",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let $ticks;
  let $thumbs;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Slider", slots, ["default"]);
  let { disabled = void 0 } = $$props;
  let { min: min2 = void 0 } = $$props;
  let { max: max2 = void 0 } = $$props;
  let { step = void 0 } = $$props;
  let { orientation = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root, ticks, thumbs }, states: { value: localValue }, updateOption, getAttrs: getAttrs2 } = setCtx26({
    disabled,
    min: min2,
    max: max2,
    step,
    orientation,
    defaultValue: value,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(9, value = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(16, $root = value2));
  validate_store(ticks, "ticks");
  component_subscribe($$self, ticks, (value2) => $$invalidate(3, $ticks = value2));
  validate_store(thumbs, "thumbs");
  component_subscribe($$self, thumbs, (value2) => $$invalidate(4, $thumbs = value2));
  const attrs = getAttrs2("root");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(8, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("disabled" in $$new_props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("min" in $$new_props) $$invalidate(11, min2 = $$new_props.min);
    if ("max" in $$new_props) $$invalidate(12, max2 = $$new_props.max);
    if ("step" in $$new_props) $$invalidate(13, step = $$new_props.step);
    if ("orientation" in $$new_props) $$invalidate(14, orientation = $$new_props.orientation);
    if ("value" in $$new_props) $$invalidate(9, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(15, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(17, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx26,
    disabled,
    min: min2,
    max: max2,
    step,
    orientation,
    value,
    onValueChange,
    asChild,
    el,
    root,
    ticks,
    thumbs,
    localValue,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root,
    $ticks,
    $thumbs
  });
  $$self.$inject_state = ($$new_props) => {
    if ("disabled" in $$props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("min" in $$props) $$invalidate(11, min2 = $$new_props.min);
    if ("max" in $$props) $$invalidate(12, max2 = $$new_props.max);
    if ("step" in $$props) $$invalidate(13, step = $$new_props.step);
    if ("orientation" in $$props) $$invalidate(14, orientation = $$new_props.orientation);
    if ("value" in $$props) $$invalidate(9, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(15, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    512) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*disabled*/
    1024) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*min*/
    2048) {
      $: updateOption("min", min2);
    }
    if ($$self.$$.dirty & /*max*/
    4096) {
      $: updateOption("max", max2);
    }
    if ($$self.$$.dirty & /*step*/
    8192) {
      $: updateOption("step", step);
    }
    if ($$self.$$.dirty & /*orientation*/
    16384) {
      $: updateOption("orientation", orientation);
    }
    if ($$self.$$.dirty & /*$root*/
    65536) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $ticks,
    $thumbs,
    root,
    ticks,
    thumbs,
    $$restProps,
    value,
    disabled,
    min2,
    max2,
    step,
    orientation,
    onValueChange,
    $root,
    $$scope,
    slots,
    span_binding
  ];
}
var Slider = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance184, create_fragment184, safe_not_equal, {
      disabled: 10,
      min: 11,
      max: 12,
      step: 13,
      orientation: 14,
      value: 9,
      onValueChange: 15,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Slider",
      options,
      id: create_fragment184.name
    });
  }
  get disabled() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get min() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set min(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get max() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set max(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get step() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set step(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get orientation() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set orientation(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Slider>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Slider>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var slider_default = Slider;

// node_modules/bits-ui/dist/bits/slider/components/slider-range.svelte
var file166 = "node_modules/bits-ui/dist/bits/slider/components/slider-range.svelte";
var get_default_slot_changes182 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context182 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block151(ctx) {
  let span;
  let builder_action_action;
  let mounted;
  let dispose;
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      children(span).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file166, 18, 1, 338);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      ctx[8](span);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block151.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block166(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context182
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes182
            ),
            get_default_slot_context182
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block166.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment185(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block166, create_else_block151];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment185.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance185($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $range;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Slider_range", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { range }, getAttrs: getAttrs2 } = getCtx24();
  validate_store(range, "range");
  component_subscribe($$self, range, (value) => $$invalidate(5, $range = value));
  const attrs = getAttrs2("range");
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx24,
    asChild,
    el,
    range,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $range
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$range*/
    32) {
      $: $$invalidate(2, builder = $range);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, range, $$restProps, $range, $$scope, slots, span_binding];
}
var Slider_range = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance185, create_fragment185, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Slider_range",
      options,
      id: create_fragment185.name
    });
  }
  get asChild() {
    throw new Error("<Slider_range>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Slider_range>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Slider_range>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Slider_range>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var slider_range_default = Slider_range;

// node_modules/bits-ui/dist/bits/slider/components/slider-thumb.svelte
var file167 = "node_modules/bits-ui/dist/bits/slider/components/slider-thumb.svelte";
var get_default_slot_changes183 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context183 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block152(ctx) {
  let span;
  let builder_action_action;
  let mounted;
  let dispose;
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      children(span).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file167, 18, 1, 431);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      ctx[8](span);
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(span)),
          listen_dev(
            span,
            "m-keydown",
            /*dispatch*/
            ctx[3],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      ctx[8](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block152.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block167(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context183
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes183
            ),
            get_default_slot_context183
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block167.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment186(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block167, create_else_block152];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment186.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance186($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "thumb"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Slider_thumb", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { thumb } = $$props;
  const { getAttrs: getAttrs2 } = getCtx24();
  const dispatch = createDispatcher();
  const attrs = getAttrs2("thumb");
  $$self.$$.on_mount.push(function() {
    if (thumb === void 0 && !("thumb" in $$props || $$self.$$.bound[$$self.$$.props["thumb"]])) {
      console.warn("<Slider_thumb> was created without expected prop 'thumb'");
    }
  });
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("thumb" in $$new_props) $$invalidate(5, thumb = $$new_props.thumb);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx24,
    createDispatcher,
    asChild,
    el,
    thumb,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("thumb" in $$props) $$invalidate(5, thumb = $$new_props.thumb);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*thumb*/
    32) {
      $: $$invalidate(2, builder = thumb);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    dispatch,
    $$restProps,
    thumb,
    $$scope,
    slots,
    span_binding
  ];
}
var Slider_thumb = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance186, create_fragment186, safe_not_equal, { asChild: 1, el: 0, thumb: 5 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Slider_thumb",
      options,
      id: create_fragment186.name
    });
  }
  get asChild() {
    throw new Error("<Slider_thumb>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Slider_thumb>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Slider_thumb>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Slider_thumb>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get thumb() {
    throw new Error("<Slider_thumb>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set thumb(value) {
    throw new Error("<Slider_thumb>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var slider_thumb_default = Slider_thumb;

// node_modules/bits-ui/dist/bits/slider/components/slider-input.svelte
var file168 = "node_modules/bits-ui/dist/bits/slider/components/slider-input.svelte";
function create_fragment187(ctx) {
  let input;
  let input_levels = [
    /*$$restProps*/
    ctx[4],
    { value: (
      /*inputValue*/
      ctx[1]
    ) },
    /*attrs*/
    ctx[3]
  ];
  let input_data = {};
  for (let i = 0; i < input_levels.length; i += 1) {
    input_data = assign(input_data, input_levels[i]);
  }
  const block = {
    c: function create() {
      input = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input = claim_element(nodes, "INPUT", {});
      this.h();
    },
    h: function hydrate() {
      set_attributes(input, input_data);
      add_location(input, file168, 22, 0, 431);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input, anchor);
      if ("value" in input_data) {
        input.value = input_data.value;
      }
      if (input.autofocus) input.focus();
      ctx[6](input);
    },
    p: function update(ctx2, [dirty]) {
      set_attributes(input, input_data = get_spread_update(input_levels, [
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4],
        dirty & /*inputValue*/
        2 && input.value !== /*inputValue*/
        ctx2[1] && { value: (
          /*inputValue*/
          ctx2[1]
        ) },
        /*attrs*/
        ctx2[3]
      ]));
      if ("value" in input_data) {
        input.value = input_data.value;
      }
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input);
      }
      ctx[6](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment187.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function getValue(value2) {
  if (value2.length === 1) {
    return value2[0];
  } else {
    return value2[1] - value2[0];
  }
}
function instance187($$self, $$props, $$invalidate) {
  let inputValue;
  const omit_props_names = ["el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $value;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Slider_input", slots, []);
  let { el = void 0 } = $$props;
  const { states: { value }, getAttrs: getAttrs2 } = getCtx24();
  validate_store(value, "value");
  component_subscribe($$self, value, (value2) => $$invalidate(5, $value = value2));
  const attrs = {
    ...getAttrs2("input"),
    style: getSrOnlyStyles()
  };
  function input_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx24,
    getSrOnlyStyles,
    el,
    value,
    getAttrs: getAttrs2,
    getValue,
    attrs,
    inputValue,
    $value
  });
  $$self.$inject_state = ($$new_props) => {
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("inputValue" in $$props) $$invalidate(1, inputValue = $$new_props.inputValue);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$value*/
    32) {
      $: $$invalidate(1, inputValue = getValue($value));
    }
  };
  return [el, inputValue, value, attrs, $$restProps, $value, input_binding];
}
var Slider_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance187, create_fragment187, safe_not_equal, { el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Slider_input",
      options,
      id: create_fragment187.name
    });
  }
  get el() {
    throw new Error("<Slider_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Slider_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var slider_input_default = Slider_input;

// node_modules/bits-ui/dist/bits/slider/components/slider-tick.svelte
var file169 = "node_modules/bits-ui/dist/bits/slider/components/slider-tick.svelte";
var get_default_slot_changes184 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context184 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block153(ctx) {
  let span;
  let builder_action_action;
  let mounted;
  let dispose;
  let span_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[3]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      children(span).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file169, 16, 1, 327);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      ctx[7](span);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(span));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        8 && /*$$restProps*/
        ctx2[3]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      ctx[7](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block153.name,
    type: "else",
    source: "(16:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block168(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[6].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[5],
    get_default_slot_context184
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        36)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[5],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[5]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[5],
              dirty,
              get_default_slot_changes184
            ),
            get_default_slot_context184
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block168.name,
    type: "if",
    source: "(14:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment188(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block168, create_else_block153];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment188.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance188($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el", "tick"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Slider_tick", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  let { tick: tick2 } = $$props;
  const { getAttrs: getAttrs2 } = getCtx24();
  const attrs = getAttrs2("tick");
  $$self.$$.on_mount.push(function() {
    if (tick2 === void 0 && !("tick" in $$props || $$self.$$.bound[$$self.$$.props["tick"]])) {
      console.warn("<Slider_tick> was created without expected prop 'tick'");
    }
  });
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(3, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("tick" in $$new_props) $$invalidate(4, tick2 = $$new_props.tick);
    if ("$$scope" in $$new_props) $$invalidate(5, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx24,
    asChild,
    el,
    tick: tick2,
    getAttrs: getAttrs2,
    attrs,
    builder
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("tick" in $$props) $$invalidate(4, tick2 = $$new_props.tick);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*tick*/
    16) {
      $: $$invalidate(2, builder = tick2);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, $$restProps, tick2, $$scope, slots, span_binding];
}
var Slider_tick = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance188, create_fragment188, safe_not_equal, { asChild: 1, el: 0, tick: 4 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Slider_tick",
      options,
      id: create_fragment188.name
    });
  }
  get asChild() {
    throw new Error("<Slider_tick>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Slider_tick>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Slider_tick>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Slider_tick>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get tick() {
    throw new Error("<Slider_tick>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set tick(value) {
    throw new Error("<Slider_tick>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var slider_tick_default = Slider_tick;

// node_modules/bits-ui/dist/bits/switch/index.js
var switch_exports = {};
__export(switch_exports, {
  Input: () => switch_input_default,
  Root: () => switch_default,
  Thumb: () => switch_thumb_default
});

// node_modules/bits-ui/dist/bits/switch/ctx.js
function getSwitchData() {
  const NAME = "switch";
  const PARTS = ["root", "input", "thumb"];
  return {
    NAME,
    PARTS
  };
}
function setCtx27(props) {
  const { NAME, PARTS } = getSwitchData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const Switch2 = { ...createSwitch(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, Switch2);
  return {
    ...Switch2,
    updateOption: getOptionUpdater(Switch2.options)
  };
}
function getCtx25() {
  const { NAME } = getSwitchData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/switch/components/switch-input.svelte
var file170 = "node_modules/bits-ui/dist/bits/switch/components/switch-input.svelte";
function create_fragment189(ctx) {
  let input_1;
  let $input_action_action;
  let mounted;
  let dispose;
  let input_1_levels = [
    /*$input*/
    ctx[2],
    { name: (
      /*$name*/
      ctx[3]
    ) },
    { disabled: (
      /*$disabled*/
      ctx[4]
    ) },
    { required: (
      /*$required*/
      ctx[5]
    ) },
    { value: (
      /*inputValue*/
      ctx[1]
    ) },
    /*$$restProps*/
    ctx[11]
  ];
  let input_data = {};
  for (let i = 0; i < input_1_levels.length; i += 1) {
    input_data = assign(input_data, input_1_levels[i]);
  }
  const block = {
    c: function create() {
      input_1 = element("input");
      this.h();
    },
    l: function claim(nodes) {
      input_1 = claim_element(nodes, "INPUT", { name: true });
      this.h();
    },
    h: function hydrate() {
      set_attributes(input_1, input_data);
      add_location(input_1, file170, 11, 0, 281);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, input_1, anchor);
      if ("value" in input_data) {
        input_1.value = input_data.value;
      }
      if (input_1.autofocus) input_1.focus();
      ctx[13](input_1);
      if (!mounted) {
        dispose = action_destroyer($input_action_action = /*$input*/
        ctx[2].action(input_1));
        mounted = true;
      }
    },
    p: function update(ctx2, [dirty]) {
      set_attributes(input_1, input_data = get_spread_update(input_1_levels, [
        dirty & /*$input*/
        4 && /*$input*/
        ctx2[2],
        dirty & /*$name*/
        8 && { name: (
          /*$name*/
          ctx2[3]
        ) },
        dirty & /*$disabled*/
        16 && { disabled: (
          /*$disabled*/
          ctx2[4]
        ) },
        dirty & /*$required*/
        32 && { required: (
          /*$required*/
          ctx2[5]
        ) },
        dirty & /*inputValue*/
        2 && input_1.value !== /*inputValue*/
        ctx2[1] && { value: (
          /*inputValue*/
          ctx2[1]
        ) },
        dirty & /*$$restProps*/
        2048 && /*$$restProps*/
        ctx2[11]
      ]));
      if ("value" in input_data) {
        input_1.value = input_data.value;
      }
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(input_1);
      }
      ctx[13](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment189.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance189($$self, $$props, $$invalidate) {
  let inputValue;
  const omit_props_names = ["el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $value;
  let $input;
  let $name;
  let $disabled;
  let $required;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Switch_input", slots, []);
  let { el = void 0 } = $$props;
  const { elements: { input }, options: { value, name: name27, disabled, required } } = getCtx25();
  validate_store(input, "input");
  component_subscribe($$self, input, (value2) => $$invalidate(2, $input = value2));
  validate_store(value, "value");
  component_subscribe($$self, value, (value2) => $$invalidate(12, $value = value2));
  validate_store(name27, "name");
  component_subscribe($$self, name27, (value2) => $$invalidate(3, $name = value2));
  validate_store(disabled, "disabled");
  component_subscribe($$self, disabled, (value2) => $$invalidate(4, $disabled = value2));
  validate_store(required, "required");
  component_subscribe($$self, required, (value2) => $$invalidate(5, $required = value2));
  function input_1_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(11, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx25,
    el,
    input,
    value,
    name: name27,
    disabled,
    required,
    inputValue,
    $value,
    $input,
    $name,
    $disabled,
    $required
  });
  $$self.$inject_state = ($$new_props) => {
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("inputValue" in $$props) $$invalidate(1, inputValue = $$new_props.inputValue);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$value*/
    4096) {
      $: $$invalidate(1, inputValue = $value === void 0 || $value === "" ? "on" : $value);
    }
  };
  return [
    el,
    inputValue,
    $input,
    $name,
    $disabled,
    $required,
    input,
    value,
    name27,
    disabled,
    required,
    $$restProps,
    $value,
    input_1_binding
  ];
}
var Switch_input = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance189, create_fragment189, safe_not_equal, { el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Switch_input",
      options,
      id: create_fragment189.name
    });
  }
  get el() {
    throw new Error("<Switch_input>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Switch_input>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var switch_input_default = Switch_input;

// node_modules/bits-ui/dist/bits/switch/components/switch.svelte
var file171 = "node_modules/bits-ui/dist/bits/switch/components/switch.svelte";
var get_default_slot_changes_1139 = (dirty) => ({ builder: dirty & /*builder*/
16 });
var get_default_slot_context_1139 = (ctx) => ({ builder: (
  /*builder*/
  ctx[4]
) });
var get_default_slot_changes185 = (dirty) => ({ builder: dirty & /*builder*/
16 });
var get_default_slot_context185 = (ctx) => ({ builder: (
  /*builder*/
  ctx[4]
) });
function create_else_block154(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[17].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[16],
    get_default_slot_context_1139
  );
  let button_levels = [
    /*builder*/
    ctx[4],
    { type: "button" },
    /*$$restProps*/
    ctx[7]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file171, 55, 1, 1244);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[18](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[4].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[6],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[6],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        65552)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[16],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[16]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[16],
              dirty,
              get_default_slot_changes_1139
            ),
            get_default_slot_context_1139
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        16 && /*builder*/
        ctx2[4],
        { type: "button" },
        dirty & /*$$restProps*/
        128 && /*$$restProps*/
        ctx2[7]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[18](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block154.name,
    type: "else",
    source: "(55:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block_121(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[17].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[16],
    get_default_slot_context185
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        65552)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[16],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[16]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[16],
              dirty,
              get_default_slot_changes185
            ),
            get_default_slot_context185
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_121.name,
    type: "if",
    source: "(53:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_if_block169(ctx) {
  let switchinput;
  let current;
  const switchinput_spread_levels = [
    /*inputAttrs*/
    ctx[3]
  ];
  let switchinput_props = {};
  for (let i = 0; i < switchinput_spread_levels.length; i += 1) {
    switchinput_props = assign(switchinput_props, switchinput_spread_levels[i]);
  }
  switchinput = new switch_input_default({ props: switchinput_props, $$inline: true });
  const block = {
    c: function create() {
      create_component(switchinput.$$.fragment);
    },
    l: function claim(nodes) {
      claim_component(switchinput.$$.fragment, nodes);
    },
    m: function mount(target, anchor) {
      mount_component(switchinput, target, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      const switchinput_changes = dirty & /*inputAttrs*/
      8 ? get_spread_update(switchinput_spread_levels, [get_spread_object(
        /*inputAttrs*/
        ctx2[3]
      )]) : {};
      switchinput.$set(switchinput_changes);
    },
    i: function intro(local) {
      if (current) return;
      transition_in(switchinput.$$.fragment, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(switchinput.$$.fragment, local);
      current = false;
    },
    d: function destroy(detaching) {
      destroy_component(switchinput, detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block169.name,
    type: "if",
    source: "(67:0) {#if includeInput}",
    ctx
  });
  return block;
}
function create_fragment190(ctx) {
  let current_block_type_index;
  let if_block0;
  let t;
  let if_block1_anchor;
  let current;
  const if_block_creators = [create_if_block_121, create_else_block154];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[2]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block0 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  let if_block1 = (
    /*includeInput*/
    ctx[1] && create_if_block169(ctx)
  );
  const block = {
    c: function create() {
      if_block0.c();
      t = space();
      if (if_block1) if_block1.c();
      if_block1_anchor = empty();
    },
    l: function claim(nodes) {
      if_block0.l(nodes);
      t = claim_space(nodes);
      if (if_block1) if_block1.l(nodes);
      if_block1_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, t, anchor);
      if (if_block1) if_block1.m(target, anchor);
      insert_hydration_dev(target, if_block1_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block0 = if_blocks[current_block_type_index];
        if (!if_block0) {
          if_block0 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block0.c();
        } else {
          if_block0.p(ctx2, dirty);
        }
        transition_in(if_block0, 1);
        if_block0.m(t.parentNode, t);
      }
      if (
        /*includeInput*/
        ctx2[1]
      ) {
        if (if_block1) {
          if_block1.p(ctx2, dirty);
          if (dirty & /*includeInput*/
          2) {
            transition_in(if_block1, 1);
          }
        } else {
          if_block1 = create_if_block169(ctx2);
          if_block1.c();
          transition_in(if_block1, 1);
          if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
        }
      } else if (if_block1) {
        group_outros();
        transition_out(if_block1, 1, 1, () => {
          if_block1 = null;
        });
        check_outros();
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block0);
      transition_in(if_block1);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block0);
      transition_out(if_block1);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(t);
        detach_dev(if_block1_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
      if (if_block1) if_block1.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment190.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance190($$self, $$props, $$invalidate) {
  let builder;
  let attrs;
  const omit_props_names = [
    "checked",
    "onCheckedChange",
    "disabled",
    "name",
    "value",
    "includeInput",
    "required",
    "asChild",
    "inputAttrs",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Switch", slots, ["default"]);
  let { checked = void 0 } = $$props;
  let { onCheckedChange = void 0 } = $$props;
  let { disabled = void 0 } = $$props;
  let { name: name27 = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { includeInput = true } = $$props;
  let { required = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { inputAttrs = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { checked: localChecked }, updateOption, getAttrs: getAttrs2 } = setCtx27({
    disabled,
    name: name27,
    value,
    required,
    defaultChecked: checked,
    onCheckedChange: ({ next: next2 }) => {
      if (checked !== next2) {
        onCheckedChange == null ? void 0 : onCheckedChange(next2);
        $$invalidate(8, checked = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(15, $root = value2));
  const dispatch = createDispatcher();
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(7, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("checked" in $$new_props) $$invalidate(8, checked = $$new_props.checked);
    if ("onCheckedChange" in $$new_props) $$invalidate(9, onCheckedChange = $$new_props.onCheckedChange);
    if ("disabled" in $$new_props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("name" in $$new_props) $$invalidate(11, name27 = $$new_props.name);
    if ("value" in $$new_props) $$invalidate(12, value = $$new_props.value);
    if ("includeInput" in $$new_props) $$invalidate(1, includeInput = $$new_props.includeInput);
    if ("required" in $$new_props) $$invalidate(13, required = $$new_props.required);
    if ("asChild" in $$new_props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("inputAttrs" in $$new_props) $$invalidate(3, inputAttrs = $$new_props.inputAttrs);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(16, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx27,
    createDispatcher,
    SwitchInput: switch_input_default,
    checked,
    onCheckedChange,
    disabled,
    name: name27,
    value,
    includeInput,
    required,
    asChild,
    inputAttrs,
    el,
    root,
    localChecked,
    updateOption,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("checked" in $$props) $$invalidate(8, checked = $$new_props.checked);
    if ("onCheckedChange" in $$props) $$invalidate(9, onCheckedChange = $$new_props.onCheckedChange);
    if ("disabled" in $$props) $$invalidate(10, disabled = $$new_props.disabled);
    if ("name" in $$props) $$invalidate(11, name27 = $$new_props.name);
    if ("value" in $$props) $$invalidate(12, value = $$new_props.value);
    if ("includeInput" in $$props) $$invalidate(1, includeInput = $$new_props.includeInput);
    if ("required" in $$props) $$invalidate(13, required = $$new_props.required);
    if ("asChild" in $$props) $$invalidate(2, asChild = $$new_props.asChild);
    if ("inputAttrs" in $$props) $$invalidate(3, inputAttrs = $$new_props.inputAttrs);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(14, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(4, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*checked*/
    256) {
      $: checked !== void 0 && localChecked.set(checked);
    }
    if ($$self.$$.dirty & /*disabled*/
    1024) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*name*/
    2048) {
      $: updateOption("name", name27);
    }
    if ($$self.$$.dirty & /*value*/
    4096) {
      $: updateOption("value", value);
    }
    if ($$self.$$.dirty & /*required*/
    8192) {
      $: updateOption("required", required);
    }
    if ($$self.$$.dirty & /*$root*/
    32768) {
      $: $$invalidate(4, builder = $root);
    }
    if ($$self.$$.dirty & /*checked*/
    256) {
      $: $$invalidate(14, attrs = {
        ...getAttrs2("root"),
        "data-checked": checked ? "" : void 0
      });
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    16400) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    includeInput,
    asChild,
    inputAttrs,
    builder,
    root,
    dispatch,
    $$restProps,
    checked,
    onCheckedChange,
    disabled,
    name27,
    value,
    required,
    attrs,
    $root,
    $$scope,
    slots,
    button_binding
  ];
}
var Switch = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance190, create_fragment190, safe_not_equal, {
      checked: 8,
      onCheckedChange: 9,
      disabled: 10,
      name: 11,
      value: 12,
      includeInput: 1,
      required: 13,
      asChild: 2,
      inputAttrs: 3,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Switch",
      options,
      id: create_fragment190.name
    });
  }
  get checked() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set checked(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onCheckedChange() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onCheckedChange(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get name() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set name(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get includeInput() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set includeInput(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get required() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set required(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inputAttrs() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inputAttrs(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Switch>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Switch>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var switch_default = Switch;

// node_modules/bits-ui/dist/bits/switch/components/switch-thumb.svelte
var file172 = "node_modules/bits-ui/dist/bits/switch/components/switch-thumb.svelte";
var get_default_slot_changes186 = (dirty) => ({
  attrs: dirty & /*attrs*/
  8,
  checked: dirty & /*$checked*/
  4
});
var get_default_slot_context186 = (ctx) => ({
  attrs: (
    /*attrs*/
    ctx[3]
  ),
  checked: (
    /*$checked*/
    ctx[2]
  )
});
function create_else_block155(ctx) {
  let span;
  let span_levels = [
    /*$$restProps*/
    ctx[5],
    /*attrs*/
    ctx[3]
  ];
  let span_data = {};
  for (let i = 0; i < span_levels.length; i += 1) {
    span_data = assign(span_data, span_levels[i]);
  }
  const block = {
    c: function create() {
      span = element("span");
      this.h();
    },
    l: function claim(nodes) {
      span = claim_element(nodes, "SPAN", {});
      children(span).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(span, span_data);
      add_location(span, file172, 18, 1, 366);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, span, anchor);
      ctx[8](span);
    },
    p: function update(ctx2, dirty) {
      set_attributes(span, span_data = get_spread_update(span_levels, [
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5],
        dirty & /*attrs*/
        8 && /*attrs*/
        ctx2[3]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(span);
      }
      ctx[8](null);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block155.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block170(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context186
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, attrs, $checked*/
        76)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes186
            ),
            get_default_slot_context186
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block170.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment191(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block170, create_else_block155];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment191.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance191($$self, $$props, $$invalidate) {
  let attrs;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $checked;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Switch_thumb", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { states: { checked }, getAttrs: getAttrs2 } = getCtx25();
  validate_store(checked, "checked");
  component_subscribe($$self, checked, (value) => $$invalidate(2, $checked = value));
  function span_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    getCtx: getCtx25,
    asChild,
    el,
    checked,
    getAttrs: getAttrs2,
    attrs,
    $checked
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(3, attrs = $$new_props.attrs);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$checked*/
    4) {
      $: $$invalidate(3, attrs = {
        ...getAttrs2("thumb"),
        "data-state": $checked ? "checked" : "unchecked",
        "data-checked": $checked ? "" : void 0
      });
    }
  };
  return [
    el,
    asChild,
    $checked,
    attrs,
    checked,
    $$restProps,
    $$scope,
    slots,
    span_binding
  ];
}
var Switch_thumb = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance191, create_fragment191, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Switch_thumb",
      options,
      id: create_fragment191.name
    });
  }
  get asChild() {
    throw new Error("<Switch_thumb>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Switch_thumb>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Switch_thumb>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Switch_thumb>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var switch_thumb_default = Switch_thumb;

// node_modules/bits-ui/dist/bits/tabs/index.js
var tabs_exports = {};
__export(tabs_exports, {
  Content: () => tabs_content_default,
  List: () => tabs_list_default,
  Root: () => tabs_default,
  Trigger: () => tabs_trigger_default
});

// node_modules/bits-ui/dist/bits/tabs/ctx.js
function getTabsData() {
  const NAME = "tabs";
  const PARTS = ["root", "content", "list", "trigger"];
  return {
    NAME,
    PARTS
  };
}
function setCtx28(props) {
  const { NAME, PARTS } = getTabsData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const tabs = { ...createTabs(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, tabs);
  return {
    ...tabs,
    updateOption: getOptionUpdater(tabs.options)
  };
}
function getCtx26() {
  const { NAME } = getTabsData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/tabs/components/tabs.svelte
var file173 = "node_modules/bits-ui/dist/bits/tabs/components/tabs.svelte";
var get_default_slot_changes_1140 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  value: dirty & /*$localValue*/
  8
});
var get_default_slot_context_1140 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  value: (
    /*$localValue*/
    ctx[3]
  )
});
var get_default_slot_changes187 = (dirty) => ({
  builder: dirty & /*builder*/
  4,
  value: dirty & /*$localValue*/
  8
});
var get_default_slot_context187 = (ctx) => ({
  builder: (
    /*builder*/
    ctx[2]
  ),
  value: (
    /*$localValue*/
    ctx[3]
  )
});
function create_else_block156(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context_1140
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[6]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file173, 49, 1, 1027);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[16](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $localValue*/
        16396)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes_1140
            ),
            get_default_slot_context_1140
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        64 && /*$$restProps*/
        ctx2[6]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[16](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block156.name,
    type: "else",
    source: "(49:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block171(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[15].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[14],
    get_default_slot_context187
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder, $localValue*/
        16396)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[14],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[14]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[14],
              dirty,
              get_default_slot_changes187
            ),
            get_default_slot_context187
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block171.name,
    type: "if",
    source: "(47:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment192(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block171, create_else_block156];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment192.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance192($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "orientation",
    "activateOnFocus",
    "loop",
    "autoSet",
    "value",
    "onValueChange",
    "asChild",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let $localValue;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tabs", slots, ["default"]);
  let { orientation = void 0 } = $$props;
  let { activateOnFocus = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { autoSet = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { value: localValue }, updateOption, getAttrs: getAttrs2 } = setCtx28({
    orientation,
    activateOnFocus,
    loop,
    autoSet,
    defaultValue: value,
    onValueChange: ({ next: next2 }) => {
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(7, value = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(13, $root = value2));
  validate_store(localValue, "localValue");
  component_subscribe($$self, localValue, (value2) => $$invalidate(3, $localValue = value2));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(6, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("orientation" in $$new_props) $$invalidate(8, orientation = $$new_props.orientation);
    if ("activateOnFocus" in $$new_props) $$invalidate(9, activateOnFocus = $$new_props.activateOnFocus);
    if ("loop" in $$new_props) $$invalidate(10, loop = $$new_props.loop);
    if ("autoSet" in $$new_props) $$invalidate(11, autoSet = $$new_props.autoSet);
    if ("value" in $$new_props) $$invalidate(7, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(12, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(14, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx28,
    orientation,
    activateOnFocus,
    loop,
    autoSet,
    value,
    onValueChange,
    asChild,
    el,
    root,
    localValue,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root,
    $localValue
  });
  $$self.$inject_state = ($$new_props) => {
    if ("orientation" in $$props) $$invalidate(8, orientation = $$new_props.orientation);
    if ("activateOnFocus" in $$props) $$invalidate(9, activateOnFocus = $$new_props.activateOnFocus);
    if ("loop" in $$props) $$invalidate(10, loop = $$new_props.loop);
    if ("autoSet" in $$props) $$invalidate(11, autoSet = $$new_props.autoSet);
    if ("value" in $$props) $$invalidate(7, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(12, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    128) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*orientation*/
    256) {
      $: updateOption("orientation", orientation);
    }
    if ($$self.$$.dirty & /*activateOnFocus*/
    512) {
      $: updateOption("activateOnFocus", activateOnFocus);
    }
    if ($$self.$$.dirty & /*loop*/
    1024) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*autoSet*/
    2048) {
      $: updateOption("autoSet", autoSet);
    }
    if ($$self.$$.dirty & /*$root*/
    8192) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    $localValue,
    root,
    localValue,
    $$restProps,
    value,
    orientation,
    activateOnFocus,
    loop,
    autoSet,
    onValueChange,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Tabs = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance192, create_fragment192, safe_not_equal, {
      orientation: 8,
      activateOnFocus: 9,
      loop: 10,
      autoSet: 11,
      value: 7,
      onValueChange: 12,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tabs",
      options,
      id: create_fragment192.name
    });
  }
  get orientation() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set orientation(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get activateOnFocus() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set activateOnFocus(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get autoSet() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set autoSet(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Tabs>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Tabs>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tabs_default = Tabs;

// node_modules/bits-ui/dist/bits/tabs/components/tabs-content.svelte
var file174 = "node_modules/bits-ui/dist/bits/tabs/components/tabs-content.svelte";
var get_default_slot_changes_1141 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1141 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes188 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context188 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block157(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1141
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file174, 19, 1, 369);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[9](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1141
            ),
            get_default_slot_context_1141
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block157.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block172(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context188
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes188
            ),
            get_default_slot_context188
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block172.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment193(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block172, create_else_block157];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment193.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance193($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["value", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $content;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tabs_content", slots, ["default"]);
  let { value } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, getAttrs: getAttrs2 } = getCtx26();
  validate_store(content, "content");
  component_subscribe($$self, content, (value2) => $$invalidate(6, $content = value2));
  const attrs = getAttrs2("content");
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Tabs_content> was created without expected prop 'value'");
    }
  });
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx26,
    value,
    asChild,
    el,
    content,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $content
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$content, value*/
    96) {
      $: $$invalidate(2, builder = $content(value));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    content,
    $$restProps,
    value,
    $content,
    $$scope,
    slots,
    div_binding
  ];
}
var Tabs_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance193, create_fragment193, safe_not_equal, { value: 5, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tabs_content",
      options,
      id: create_fragment193.name
    });
  }
  get value() {
    throw new Error("<Tabs_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Tabs_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Tabs_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Tabs_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Tabs_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Tabs_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tabs_content_default = Tabs_content;

// node_modules/bits-ui/dist/bits/tabs/components/tabs-list.svelte
var file175 = "node_modules/bits-ui/dist/bits/tabs/components/tabs-list.svelte";
var get_default_slot_changes_1142 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1142 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes189 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context189 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block158(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context_1142
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file175, 18, 1, 335);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[8](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes_1142
            ),
            get_default_slot_context_1142
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[8](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block158.name,
    type: "else",
    source: "(18:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block173(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[7].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[6],
    get_default_slot_context189
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        68)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[6],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[6]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[6],
              dirty,
              get_default_slot_changes189
            ),
            get_default_slot_context189
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block173.name,
    type: "if",
    source: "(16:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment194(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block173, create_else_block158];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment194.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance194($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $list;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tabs_list", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { list }, getAttrs: getAttrs2 } = getCtx26();
  validate_store(list, "list");
  component_subscribe($$self, list, (value) => $$invalidate(5, $list = value));
  const attrs = getAttrs2("list");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(6, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx26,
    asChild,
    el,
    list,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $list
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$list*/
    32) {
      $: $$invalidate(2, builder = $list);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [el, asChild, builder, list, $$restProps, $list, $$scope, slots, div_binding];
}
var Tabs_list = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance194, create_fragment194, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tabs_list",
      options,
      id: create_fragment194.name
    });
  }
  get asChild() {
    throw new Error("<Tabs_list>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Tabs_list>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Tabs_list>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Tabs_list>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tabs_list_default = Tabs_list;

// node_modules/bits-ui/dist/bits/tabs/components/tabs-trigger.svelte
var file176 = "node_modules/bits-ui/dist/bits/tabs/components/tabs-trigger.svelte";
var get_default_slot_changes_1143 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1143 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes190 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context190 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block159(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_1143
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file176, 22, 1, 514);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[11](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-focus",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_1143
            ),
            get_default_slot_context_1143
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block159.name,
    type: "else",
    source: "(22:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block174(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context190
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes190
            ),
            get_default_slot_context190
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block174.name,
    type: "if",
    source: "(20:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment195(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block174, create_else_block159];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment195.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance195($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["value", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tabs_trigger", slots, ["default"]);
  let { value } = $$props;
  let { disabled = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, getAttrs: getAttrs2 } = getCtx26();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value2) => $$invalidate(8, $trigger = value2));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Tabs_trigger> was created without expected prop 'value'");
    }
  });
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx26,
    createDispatcher,
    value,
    disabled,
    asChild,
    el,
    trigger,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$trigger, value, disabled*/
    448) {
      $: $$invalidate(2, builder = $trigger({ value, disabled }));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    value,
    disabled,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Tabs_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance195, create_fragment195, safe_not_equal, { value: 6, disabled: 7, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tabs_trigger",
      options,
      id: create_fragment195.name
    });
  }
  get value() {
    throw new Error("<Tabs_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Tabs_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Tabs_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Tabs_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Tabs_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Tabs_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Tabs_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Tabs_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tabs_trigger_default = Tabs_trigger;

// node_modules/bits-ui/dist/bits/toggle/index.js
var toggle_exports = {};
__export(toggle_exports, {
  Root: () => toggle_default
});

// node_modules/bits-ui/dist/bits/toggle/ctx.js
function getToggleData() {
  const NAME = "toggle";
  const PARTS = ["root", "input"];
  return {
    NAME,
    PARTS
  };
}
function setCtx29(props) {
  const { NAME, PARTS } = getToggleData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const toggle2 = { ...createToggle(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, toggle2);
  return {
    ...toggle2,
    updateOption: getOptionUpdater(toggle2.options)
  };
}

// node_modules/bits-ui/dist/bits/toggle/components/toggle.svelte
var file177 = "node_modules/bits-ui/dist/bits/toggle/components/toggle.svelte";
var get_default_slot_changes_1144 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1144 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes191 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context191 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block160(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_1144
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file177, 39, 1, 865);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[12](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_1144
            ),
            get_default_slot_context_1144
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block160.name,
    type: "else",
    source: "(39:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block175(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context191
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes191
            ),
            get_default_slot_context191
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block175.name,
    type: "if",
    source: "(37:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment196(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block175, create_else_block160];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment196.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance196($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["disabled", "pressed", "onPressedChange", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toggle", slots, ["default"]);
  let { disabled = void 0 } = $$props;
  let { pressed = void 0 } = $$props;
  let { onPressedChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { pressed: localPressed }, updateOption, getAttrs: getAttrs2 } = setCtx29({
    disabled,
    defaultPressed: pressed,
    onPressedChange: ({ next: next2 }) => {
      if (pressed !== next2) {
        onPressedChange == null ? void 0 : onPressedChange(next2);
        $$invalidate(6, pressed = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value) => $$invalidate(9, $root = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("root");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("pressed" in $$new_props) $$invalidate(6, pressed = $$new_props.pressed);
    if ("onPressedChange" in $$new_props) $$invalidate(8, onPressedChange = $$new_props.onPressedChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx29,
    createDispatcher,
    disabled,
    pressed,
    onPressedChange,
    asChild,
    el,
    root,
    localPressed,
    updateOption,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("pressed" in $$props) $$invalidate(6, pressed = $$new_props.pressed);
    if ("onPressedChange" in $$props) $$invalidate(8, onPressedChange = $$new_props.onPressedChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*pressed*/
    64) {
      $: pressed !== void 0 && localPressed.set(pressed);
    }
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*$root*/
    512) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    dispatch,
    $$restProps,
    pressed,
    disabled,
    onPressedChange,
    $root,
    $$scope,
    slots,
    button_binding
  ];
}
var Toggle = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance196, create_fragment196, safe_not_equal, {
      disabled: 7,
      pressed: 6,
      onPressedChange: 8,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toggle",
      options,
      id: create_fragment196.name
    });
  }
  get disabled() {
    throw new Error("<Toggle>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Toggle>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get pressed() {
    throw new Error("<Toggle>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set pressed(value) {
    throw new Error("<Toggle>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onPressedChange() {
    throw new Error("<Toggle>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onPressedChange(value) {
    throw new Error("<Toggle>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Toggle>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toggle>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toggle>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toggle>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toggle_default = Toggle;

// node_modules/bits-ui/dist/bits/toggle-group/index.js
var toggle_group_exports = {};
__export(toggle_group_exports, {
  Item: () => toggle_group_item_default,
  Root: () => toggle_group_default
});

// node_modules/bits-ui/dist/bits/toggle-group/ctx.js
function getToggleGroupData() {
  const NAME = "toggle-group";
  const PARTS = ["root", "item"];
  return {
    NAME,
    PARTS
  };
}
function setCtx30(props) {
  const { NAME, PARTS } = getToggleGroupData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const toggleGroup = { ...createToggleGroup(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, toggleGroup);
  return {
    ...toggleGroup,
    updateOption: getOptionUpdater(toggleGroup.options)
  };
}
function getCtx27() {
  const { NAME } = getToggleGroupData();
  return getContext(NAME);
}

// node_modules/bits-ui/dist/bits/toggle-group/components/toggle-group.svelte
var file178 = "node_modules/bits-ui/dist/bits/toggle-group/components/toggle-group.svelte";
var get_default_slot_changes_1145 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1145 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes192 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context192 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block161(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context_1145
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file178, 58, 1, 1272);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[14](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes_1145
            ),
            get_default_slot_context_1145
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[14](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block161.name,
    type: "else",
    source: "(58:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block176(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[13].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[12],
    get_default_slot_context192
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        4100)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[12],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[12]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[12],
              dirty,
              get_default_slot_changes192
            ),
            get_default_slot_context192
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block176.name,
    type: "if",
    source: "(56:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment197(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block176, create_else_block161];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment197.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance197($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["type", "disabled", "loop", "value", "orientation", "onValueChange", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toggle_group", slots, ["default"]);
  let { type = "single" } = $$props;
  let { disabled = void 0 } = $$props;
  let { loop = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { orientation = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, states: { value: localValue }, updateOption, getAttrs: getAttrs2 } = setCtx30({
    disabled,
    type,
    defaultValue: value,
    loop,
    orientation,
    onValueChange: ({ next: next2 }) => {
      if (Array.isArray(next2)) {
        if (!Array.isArray(value) || !arraysAreEqual(value, next2)) {
          onValueChange == null ? void 0 : onValueChange(next2);
          $$invalidate(5, value = next2);
          return next2;
        }
        return next2;
      }
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(5, value = next2);
      }
      return next2;
    }
  });
  validate_store(root, "root");
  component_subscribe($$self, root, (value2) => $$invalidate(11, $root = value2));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("type" in $$new_props) $$invalidate(6, type = $$new_props.type);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("loop" in $$new_props) $$invalidate(8, loop = $$new_props.loop);
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("orientation" in $$new_props) $$invalidate(9, orientation = $$new_props.orientation);
    if ("onValueChange" in $$new_props) $$invalidate(10, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(12, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    arraysAreEqual,
    melt,
    setCtx: setCtx30,
    type,
    disabled,
    loop,
    value,
    orientation,
    onValueChange,
    asChild,
    el,
    root,
    localValue,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("type" in $$props) $$invalidate(6, type = $$new_props.type);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("loop" in $$props) $$invalidate(8, loop = $$new_props.loop);
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("orientation" in $$props) $$invalidate(9, orientation = $$new_props.orientation);
    if ("onValueChange" in $$props) $$invalidate(10, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    32) {
      $: value !== void 0 && localValue.set(Array.isArray(value) ? [...value] : value);
    }
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*loop*/
    256) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*type*/
    64) {
      $: updateOption("type", type);
    }
    if ($$self.$$.dirty & /*orientation*/
    512) {
      $: updateOption("orientation", orientation);
    }
    if ($$self.$$.dirty & /*$root*/
    2048) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    $$restProps,
    value,
    type,
    disabled,
    loop,
    orientation,
    onValueChange,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Toggle_group = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance197, create_fragment197, safe_not_equal, {
      type: 6,
      disabled: 7,
      loop: 8,
      value: 5,
      orientation: 9,
      onValueChange: 10,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toggle_group",
      options,
      id: create_fragment197.name
    });
  }
  get type() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set type(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get loop() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get orientation() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set orientation(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toggle_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toggle_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toggle_group_default = Toggle_group;

// node_modules/bits-ui/dist/bits/toggle-group/components/toggle-group-item.svelte
var file179 = "node_modules/bits-ui/dist/bits/toggle-group/components/toggle-group-item.svelte";
var get_default_slot_changes_1146 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1146 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes193 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context193 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block162(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context_1146
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", {});
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file179, 22, 1, 503);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[11](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes_1146
            ),
            get_default_slot_context_1146
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[11](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block162.name,
    type: "else",
    source: "(22:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block177(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[10].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[9],
    get_default_slot_context193
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        516)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[9],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[9]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[9],
              dirty,
              get_default_slot_changes193
            ),
            get_default_slot_context193
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block177.name,
    type: "if",
    source: "(20:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment198(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block177, create_else_block162];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment198.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance198($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["value", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $item;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toggle_group_item", slots, ["default"]);
  let { value } = $$props;
  let { disabled = false } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { item }, getAttrs: getAttrs2 } = getCtx27();
  validate_store(item, "item");
  component_subscribe($$self, item, (value2) => $$invalidate(8, $item = value2));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("item");
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Toggle_group_item> was created without expected prop 'value'");
    }
  });
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(9, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx27,
    createDispatcher,
    value,
    disabled,
    asChild,
    el,
    item,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $item
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$item, value, disabled*/
    448) {
      $: $$invalidate(2, builder = $item({ value, disabled }));
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    item,
    dispatch,
    $$restProps,
    value,
    disabled,
    $item,
    $$scope,
    slots,
    button_binding
  ];
}
var Toggle_group_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance198, create_fragment198, safe_not_equal, { value: 6, disabled: 7, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toggle_group_item",
      options,
      id: create_fragment198.name
    });
  }
  get value() {
    throw new Error("<Toggle_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Toggle_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Toggle_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Toggle_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Toggle_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toggle_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toggle_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toggle_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toggle_group_item_default = Toggle_group_item;

// node_modules/bits-ui/dist/bits/toolbar/index.js
var toolbar_exports = {};
__export(toolbar_exports, {
  Button: () => toolbar_button_default,
  Group: () => toolbar_group_default,
  GroupItem: () => toolbar_group_item_default,
  Link: () => toolbar_link_default,
  Root: () => toolbar_default
});

// node_modules/bits-ui/dist/bits/toolbar/ctx.js
function getToolbarData() {
  const NAME = "toolbar";
  const GROUP_NAME = "toolbar-group";
  const PARTS = ["root", "button", "link", "group", "group-item"];
  return {
    NAME,
    GROUP_NAME,
    PARTS
  };
}
function setCtx31(props) {
  const { NAME, PARTS } = getToolbarData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const toolbar = { ...createToolbar(removeUndefined2(props)), getAttrs: getAttrs2 };
  setContext(NAME, toolbar);
  return {
    ...toolbar,
    updateOption: getOptionUpdater(toolbar.options)
  };
}
function setGroupCtx4(props) {
  const { builders: { createToolbarGroup }, getAttrs: getAttrs2 } = getCtx28();
  const group = { ...createToolbarGroup(removeUndefined2(props)), getAttrs: getAttrs2 };
  const { GROUP_NAME } = getToolbarData();
  setContext(GROUP_NAME, group);
  return {
    ...group,
    updateOption: getOptionUpdater(group.options)
  };
}
function getCtx28() {
  const { NAME } = getToolbarData();
  return getContext(NAME);
}
function getGroupCtx() {
  const { GROUP_NAME } = getToolbarData();
  return getContext(GROUP_NAME);
}

// node_modules/bits-ui/dist/bits/toolbar/components/toolbar.svelte
var file180 = "node_modules/bits-ui/dist/bits/toolbar/components/toolbar.svelte";
var get_default_slot_changes_1147 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1147 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes194 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context194 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block163(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_1147
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file180, 28, 1, 513);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[10](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_1147
            ),
            get_default_slot_context_1147
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block163.name,
    type: "else",
    source: "(28:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block178(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context194
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes194
            ),
            get_default_slot_context194
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block178.name,
    type: "if",
    source: "(26:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment199(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block178, create_else_block163];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment199.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance199($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["loop", "orientation", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $root;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toolbar", slots, ["default"]);
  let { loop = true } = $$props;
  let { orientation = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { root }, updateOption, getAttrs: getAttrs2 } = setCtx31({ loop, orientation });
  validate_store(root, "root");
  component_subscribe($$self, root, (value) => $$invalidate(7, $root = value));
  const attrs = getAttrs2("root");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("loop" in $$new_props) $$invalidate(5, loop = $$new_props.loop);
    if ("orientation" in $$new_props) $$invalidate(6, orientation = $$new_props.orientation);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setCtx: setCtx31,
    loop,
    orientation,
    asChild,
    el,
    root,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $root
  });
  $$self.$inject_state = ($$new_props) => {
    if ("loop" in $$props) $$invalidate(5, loop = $$new_props.loop);
    if ("orientation" in $$props) $$invalidate(6, orientation = $$new_props.orientation);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*loop*/
    32) {
      $: updateOption("loop", loop);
    }
    if ($$self.$$.dirty & /*orientation*/
    64) {
      $: updateOption("orientation", orientation);
    }
    if ($$self.$$.dirty & /*$root*/
    128) {
      $: $$invalidate(2, builder = $root);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    root,
    $$restProps,
    loop,
    orientation,
    $root,
    $$scope,
    slots,
    div_binding
  ];
}
var Toolbar = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance199, create_fragment199, safe_not_equal, {
      loop: 5,
      orientation: 6,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toolbar",
      options,
      id: create_fragment199.name
    });
  }
  get loop() {
    throw new Error("<Toolbar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set loop(value) {
    throw new Error("<Toolbar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get orientation() {
    throw new Error("<Toolbar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set orientation(value) {
    throw new Error("<Toolbar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Toolbar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toolbar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toolbar>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toolbar>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toolbar_default = Toolbar;

// node_modules/bits-ui/dist/bits/toolbar/components/toolbar-button.svelte
var file181 = "node_modules/bits-ui/dist/bits/toolbar/components/toolbar-button.svelte";
var get_default_slot_changes_1148 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1148 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes195 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context195 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block164(ctx) {
  let button_1;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1148
  );
  let button_1_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_1_levels.length; i += 1) {
    button_data = assign(button_data, button_1_levels[i]);
  }
  const block = {
    c: function create() {
      button_1 = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button_1 = claim_element(nodes, "BUTTON", { type: true });
      var button_1_nodes = children(button_1);
      if (default_slot) default_slot.l(button_1_nodes);
      button_1_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button_1, button_data);
      add_location(button_1, file181, 20, 1, 442);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button_1, anchor);
      if (default_slot) {
        default_slot.m(button_1, null);
      }
      if (button_1.autofocus) button_1.focus();
      ctx[10](button_1);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button_1)),
          listen_dev(
            button_1,
            "click",
            /*click_handler*/
            ctx[9],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button_1,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1148
            ),
            get_default_slot_context_1148
          );
        }
      }
      set_attributes(button_1, button_data = get_spread_update(button_1_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button_1);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block164.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block179(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context195
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes195
            ),
            get_default_slot_context195
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block179.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment200(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block179, create_else_block164];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment200.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance200($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $button;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toolbar_button", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { button }, getAttrs: getAttrs2 } = getCtx28();
  validate_store(button, "button");
  component_subscribe($$self, button, (value) => $$invalidate(6, $button = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("button");
  function click_handler(event) {
    bubble.call(this, $$self, event);
  }
  function button_1_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx28,
    createDispatcher,
    asChild,
    el,
    button,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $button
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$button*/
    64) {
      $: $$invalidate(2, builder = $button);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    button,
    dispatch,
    $$restProps,
    $button,
    $$scope,
    slots,
    click_handler,
    button_1_binding
  ];
}
var Toolbar_button = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance200, create_fragment200, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toolbar_button",
      options,
      id: create_fragment200.name
    });
  }
  get asChild() {
    throw new Error("<Toolbar_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toolbar_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toolbar_button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toolbar_button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toolbar_button_default = Toolbar_button;

// node_modules/bits-ui/dist/bits/toolbar/components/toolbar-link.svelte
var file182 = "node_modules/bits-ui/dist/bits/toolbar/components/toolbar-link.svelte";
var get_default_slot_changes_1149 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1149 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes196 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context196 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block165(ctx) {
  let current;
  validate_dynamic_element("a");
  validate_void_dynamic_element("a");
  let svelte_element = create_dynamic_element6(ctx);
  const block = {
    c: function create() {
      if (svelte_element) svelte_element.c();
    },
    l: function claim(nodes) {
      if (svelte_element) svelte_element.l(nodes);
    },
    m: function mount(target, anchor) {
      if (svelte_element) svelte_element.m(target, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      if ("a") {
        svelte_element.p(ctx2, dirty);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(svelte_element, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(svelte_element, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (svelte_element) svelte_element.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block165.name,
    type: "else",
    source: "(20:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block180(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context196
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes196
            ),
            get_default_slot_context196
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block180.name,
    type: "if",
    source: "(18:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_dynamic_element6(ctx) {
  let svelte_element;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context_1149
  );
  let svelte_element_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let svelte_element_data = {};
  for (let i = 0; i < svelte_element_levels.length; i += 1) {
    svelte_element_data = assign(svelte_element_data, svelte_element_levels[i]);
  }
  const block = {
    c: function create() {
      svelte_element = element("a");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      svelte_element = claim_element(nodes, "A", {});
      var svelte_element_nodes = children(svelte_element);
      if (default_slot) default_slot.l(svelte_element_nodes);
      svelte_element_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_dynamic_element_data("a")(svelte_element, svelte_element_data);
      add_location(svelte_element, file182, 21, 1, 496);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, svelte_element, anchor);
      if (default_slot) {
        default_slot.m(svelte_element, null);
      }
      ctx[10](svelte_element);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(svelte_element)),
          listen_dev(
            svelte_element,
            "click",
            /*click_handler*/
            ctx[9],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            svelte_element,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes_1149
            ),
            get_default_slot_context_1149
          );
        }
      }
      set_dynamic_element_data("a")(svelte_element, svelte_element_data = get_spread_update(svelte_element_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(svelte_element);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_dynamic_element6.name,
    type: "child_dynamic_element",
    source: '(22:1) <svelte:element   this={\\"a\\"}   bind:this={el}   {...builder} use:builder.action   {...$$restProps}   on:click   on:m-keydown={dispatch}  >',
    ctx
  });
  return block;
}
function create_fragment201(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block180, create_else_block165];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment201.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance201($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $link;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toolbar_link", slots, ["default"]);
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { link }, getAttrs: getAttrs2 } = getCtx28();
  validate_store(link, "link");
  component_subscribe($$self, link, (value) => $$invalidate(6, $link = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("link");
  function click_handler(event) {
    bubble.call(this, $$self, event);
  }
  function svelte_element_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getCtx: getCtx28,
    createDispatcher,
    asChild,
    el,
    link,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $link
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$link*/
    64) {
      $: $$invalidate(2, builder = $link);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    link,
    dispatch,
    $$restProps,
    $link,
    $$scope,
    slots,
    click_handler,
    svelte_element_binding
  ];
}
var Toolbar_link = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance201, create_fragment201, safe_not_equal, { asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toolbar_link",
      options,
      id: create_fragment201.name
    });
  }
  get asChild() {
    throw new Error("<Toolbar_link>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toolbar_link>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toolbar_link>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toolbar_link>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toolbar_link_default = Toolbar_link;

// node_modules/bits-ui/dist/bits/toolbar/components/toolbar-group.svelte
var file183 = "node_modules/bits-ui/dist/bits/toolbar/components/toolbar-group.svelte";
var get_default_slot_changes_1150 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1150 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes197 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context197 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block166(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_1150
  );
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file183, 46, 1, 925);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[12](div);
      current = true;
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_1150
            ),
            get_default_slot_context_1150
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block166.name,
    type: "else",
    source: "(46:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block181(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context197
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes197
            ),
            get_default_slot_context197
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block181.name,
    type: "if",
    source: "(44:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment202(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block181, create_else_block166];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment202.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance202($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["type", "disabled", "value", "onValueChange", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $group;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toolbar_group", slots, ["default"]);
  let { type = "single" } = $$props;
  let { disabled = void 0 } = $$props;
  let { value = void 0 } = $$props;
  let { onValueChange = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { group }, states: { value: localValue }, updateOption, getAttrs: getAttrs2 } = setGroupCtx4({
    disabled,
    type,
    defaultValue: value,
    onValueChange: ({ next: next2 }) => {
      if (Array.isArray(next2)) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(5, value = next2);
        return next2;
      }
      if (value !== next2) {
        onValueChange == null ? void 0 : onValueChange(next2);
        $$invalidate(5, value = next2);
      }
      return next2;
    }
  });
  validate_store(group, "group");
  component_subscribe($$self, group, (value2) => $$invalidate(9, $group = value2));
  const attrs = getAttrs2("group");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("type" in $$new_props) $$invalidate(6, type = $$new_props.type);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("value" in $$new_props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$new_props) $$invalidate(8, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setGroupCtx: setGroupCtx4,
    type,
    disabled,
    value,
    onValueChange,
    asChild,
    el,
    group,
    localValue,
    updateOption,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $group
  });
  $$self.$inject_state = ($$new_props) => {
    if ("type" in $$props) $$invalidate(6, type = $$new_props.type);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("value" in $$props) $$invalidate(5, value = $$new_props.value);
    if ("onValueChange" in $$props) $$invalidate(8, onValueChange = $$new_props.onValueChange);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*value*/
    32) {
      $: value !== void 0 && localValue.set(value);
    }
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: updateOption("disabled", disabled);
    }
    if ($$self.$$.dirty & /*type*/
    64) {
      $: updateOption("type", type);
    }
    if ($$self.$$.dirty & /*$group*/
    512) {
      $: $$invalidate(2, builder = $group);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    group,
    $$restProps,
    value,
    type,
    disabled,
    onValueChange,
    $group,
    $$scope,
    slots,
    div_binding
  ];
}
var Toolbar_group = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance202, create_fragment202, safe_not_equal, {
      type: 6,
      disabled: 7,
      value: 5,
      onValueChange: 8,
      asChild: 1,
      el: 0
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toolbar_group",
      options,
      id: create_fragment202.name
    });
  }
  get type() {
    throw new Error("<Toolbar_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set type(value) {
    throw new Error("<Toolbar_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Toolbar_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Toolbar_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get value() {
    throw new Error("<Toolbar_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Toolbar_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onValueChange() {
    throw new Error("<Toolbar_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onValueChange(value) {
    throw new Error("<Toolbar_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Toolbar_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toolbar_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toolbar_group>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toolbar_group>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toolbar_group_default = Toolbar_group;

// node_modules/bits-ui/dist/bits/toolbar/components/toolbar-group-item.svelte
var file184 = "node_modules/bits-ui/dist/bits/toolbar/components/toolbar-group-item.svelte";
var get_default_slot_changes_1151 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1151 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes198 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context198 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block167(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context_1151
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", {});
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file184, 23, 1, 568);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[12](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-click",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes_1151
            ),
            get_default_slot_context_1151
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[12](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block167.name,
    type: "else",
    source: "(23:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block182(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[11].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[10],
    get_default_slot_context198
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        1028)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[10],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[10]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[10],
              dirty,
              get_default_slot_changes198
            ),
            get_default_slot_context198
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block182.name,
    type: "if",
    source: "(21:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment203(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block182, create_else_block167];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment203.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance203($$self, $$props, $$invalidate) {
  let attrs;
  let builder;
  const omit_props_names = ["value", "disabled", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $item;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Toolbar_group_item", slots, ["default"]);
  let { value } = $$props;
  let { disabled = false } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { item }, getAttrs: getAttrs2 } = getGroupCtx();
  validate_store(item, "item");
  component_subscribe($$self, item, (value2) => $$invalidate(9, $item = value2));
  const dispatch = createDispatcher();
  $$self.$$.on_mount.push(function() {
    if (value === void 0 && !("value" in $$props || $$self.$$.bound[$$self.$$.props["value"]])) {
      console.warn("<Toolbar_group_item> was created without expected prop 'value'");
    }
  });
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("value" in $$new_props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$new_props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(10, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    getGroupCtx,
    createDispatcher,
    disabledAttrs,
    value,
    disabled,
    asChild,
    el,
    item,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $item
  });
  $$self.$inject_state = ($$new_props) => {
    if ("value" in $$props) $$invalidate(6, value = $$new_props.value);
    if ("disabled" in $$props) $$invalidate(7, disabled = $$new_props.disabled);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("attrs" in $$props) $$invalidate(8, attrs = $$new_props.attrs);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*disabled*/
    128) {
      $: $$invalidate(8, attrs = {
        ...getAttrs2("group-item"),
        ...disabledAttrs(disabled)
      });
    }
    if ($$self.$$.dirty & /*$item, value, disabled*/
    704) {
      $: $$invalidate(2, builder = $item({ value, disabled }));
    }
    if ($$self.$$.dirty & /*builder, attrs*/
    260) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    item,
    dispatch,
    $$restProps,
    value,
    disabled,
    attrs,
    $item,
    $$scope,
    slots,
    button_binding
  ];
}
var Toolbar_group_item = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance203, create_fragment203, safe_not_equal, { value: 6, disabled: 7, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Toolbar_group_item",
      options,
      id: create_fragment203.name
    });
  }
  get value() {
    throw new Error("<Toolbar_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set value(value) {
    throw new Error("<Toolbar_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disabled() {
    throw new Error("<Toolbar_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disabled(value) {
    throw new Error("<Toolbar_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Toolbar_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Toolbar_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Toolbar_group_item>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Toolbar_group_item>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var toolbar_group_item_default = Toolbar_group_item;

// node_modules/bits-ui/dist/bits/tooltip/index.js
var tooltip_exports = {};
__export(tooltip_exports, {
  Arrow: () => tooltip_arrow_default,
  Content: () => tooltip_content_default,
  Root: () => tooltip_default,
  Trigger: () => tooltip_trigger_default
});

// node_modules/bits-ui/dist/bits/tooltip/ctx.js
function getTooltipData() {
  const NAME = "tooltip";
  const PARTS = ["arrow", "content", "trigger"];
  return {
    NAME,
    PARTS
  };
}
function setCtx32(props) {
  const { NAME, PARTS } = getTooltipData();
  const getAttrs2 = createBitAttrs(NAME, PARTS);
  const tooltip = {
    ...createTooltip({
      positioning: {
        placement: "top",
        gutter: 0
      },
      openDelay: 700,
      ...removeUndefined2(props),
      forceVisible: true
    }),
    getAttrs: getAttrs2
  };
  setContext(NAME, tooltip);
  return {
    ...tooltip,
    updateOption: getOptionUpdater(tooltip.options)
  };
}
function getCtx29() {
  const { NAME } = getTooltipData();
  return getContext(NAME);
}
function setArrow6(size3 = 8) {
  const tooltip = getCtx29();
  tooltip.options.arrowSize.set(size3);
  return tooltip;
}
function updatePositioning10(props) {
  const defaultPlacement = {
    side: "top",
    align: "center",
    sideOffset: 1
  };
  const withDefaults = { ...defaultPlacement, ...props };
  const { options: { positioning } } = getCtx29();
  const updater = getPositioningUpdater(positioning);
  updater({ ...withDefaults });
}

// node_modules/bits-ui/dist/bits/tooltip/components/tooltip.svelte
var get_default_slot_changes199 = (dirty) => ({ ids: dirty & /*$idValues*/
1 });
var get_default_slot_context199 = (ctx) => ({ ids: (
  /*$idValues*/
  ctx[0]
) });
function create_fragment204(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[12].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[11],
    get_default_slot_context199
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, $idValues*/
        2049)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[11],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[11]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[11],
              dirty,
              get_default_slot_changes199
            ),
            get_default_slot_context199
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment204.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance204($$self, $$props, $$invalidate) {
  let $idValues;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tooltip", slots, ["default"]);
  let { closeOnEscape = void 0 } = $$props;
  let { portal = void 0 } = $$props;
  let { closeOnPointerDown = void 0 } = $$props;
  let { openDelay = void 0 } = $$props;
  let { closeDelay = void 0 } = $$props;
  let { open = void 0 } = $$props;
  let { onOpenChange = void 0 } = $$props;
  let { disableHoverableContent = void 0 } = $$props;
  let { group = void 0 } = $$props;
  const { states: { open: localOpen }, updateOption, ids } = setCtx32({
    closeOnEscape,
    portal,
    closeOnPointerDown,
    openDelay,
    closeDelay,
    forceVisible: true,
    defaultOpen: open,
    disableHoverableContent,
    group,
    onOpenChange: ({ next: next2 }) => {
      if (open !== next2) {
        onOpenChange == null ? void 0 : onOpenChange(next2);
        $$invalidate(2, open = next2);
      }
      return next2;
    },
    positioning: { gutter: 0, offset: { mainAxis: 1 } }
  });
  const idValues = derived([ids.content, ids.trigger], ([$contentId, $triggerId]) => ({ content: $contentId, trigger: $triggerId }));
  validate_store(idValues, "idValues");
  component_subscribe($$self, idValues, (value) => $$invalidate(0, $idValues = value));
  const writable_props = [
    "closeOnEscape",
    "portal",
    "closeOnPointerDown",
    "openDelay",
    "closeDelay",
    "open",
    "onOpenChange",
    "disableHoverableContent",
    "group"
  ];
  Object.keys($$props).forEach((key) => {
    if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot") console.warn(`<Tooltip> was created with unknown prop '${key}'`);
  });
  $$self.$$set = ($$props2) => {
    if ("closeOnEscape" in $$props2) $$invalidate(3, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(4, portal = $$props2.portal);
    if ("closeOnPointerDown" in $$props2) $$invalidate(5, closeOnPointerDown = $$props2.closeOnPointerDown);
    if ("openDelay" in $$props2) $$invalidate(6, openDelay = $$props2.openDelay);
    if ("closeDelay" in $$props2) $$invalidate(7, closeDelay = $$props2.closeDelay);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(8, onOpenChange = $$props2.onOpenChange);
    if ("disableHoverableContent" in $$props2) $$invalidate(9, disableHoverableContent = $$props2.disableHoverableContent);
    if ("group" in $$props2) $$invalidate(10, group = $$props2.group);
    if ("$$scope" in $$props2) $$invalidate(11, $$scope = $$props2.$$scope);
  };
  $$self.$capture_state = () => ({
    derived,
    setCtx: setCtx32,
    closeOnEscape,
    portal,
    closeOnPointerDown,
    openDelay,
    closeDelay,
    open,
    onOpenChange,
    disableHoverableContent,
    group,
    localOpen,
    updateOption,
    ids,
    idValues,
    $idValues
  });
  $$self.$inject_state = ($$props2) => {
    if ("closeOnEscape" in $$props2) $$invalidate(3, closeOnEscape = $$props2.closeOnEscape);
    if ("portal" in $$props2) $$invalidate(4, portal = $$props2.portal);
    if ("closeOnPointerDown" in $$props2) $$invalidate(5, closeOnPointerDown = $$props2.closeOnPointerDown);
    if ("openDelay" in $$props2) $$invalidate(6, openDelay = $$props2.openDelay);
    if ("closeDelay" in $$props2) $$invalidate(7, closeDelay = $$props2.closeDelay);
    if ("open" in $$props2) $$invalidate(2, open = $$props2.open);
    if ("onOpenChange" in $$props2) $$invalidate(8, onOpenChange = $$props2.onOpenChange);
    if ("disableHoverableContent" in $$props2) $$invalidate(9, disableHoverableContent = $$props2.disableHoverableContent);
    if ("group" in $$props2) $$invalidate(10, group = $$props2.group);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*open*/
    4) {
      $: open !== void 0 && localOpen.set(open);
    }
    if ($$self.$$.dirty & /*closeOnEscape*/
    8) {
      $: updateOption("closeOnEscape", closeOnEscape);
    }
    if ($$self.$$.dirty & /*portal*/
    16) {
      $: updateOption("portal", portal);
    }
    if ($$self.$$.dirty & /*closeOnPointerDown*/
    32) {
      $: updateOption("closeOnPointerDown", closeOnPointerDown);
    }
    if ($$self.$$.dirty & /*openDelay*/
    64) {
      $: updateOption("openDelay", openDelay);
    }
    if ($$self.$$.dirty & /*closeDelay*/
    128) {
      $: updateOption("closeDelay", closeDelay);
    }
    if ($$self.$$.dirty & /*group*/
    1024) {
      $: updateOption("group", group);
    }
    if ($$self.$$.dirty & /*disableHoverableContent*/
    512) {
      $: updateOption("disableHoverableContent", disableHoverableContent);
    }
  };
  return [
    $idValues,
    idValues,
    open,
    closeOnEscape,
    portal,
    closeOnPointerDown,
    openDelay,
    closeDelay,
    onOpenChange,
    disableHoverableContent,
    group,
    $$scope,
    slots
  ];
}
var Tooltip = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance204, create_fragment204, safe_not_equal, {
      closeOnEscape: 3,
      portal: 4,
      closeOnPointerDown: 5,
      openDelay: 6,
      closeDelay: 7,
      open: 2,
      onOpenChange: 8,
      disableHoverableContent: 9,
      group: 10
    });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tooltip",
      options,
      id: create_fragment204.name
    });
  }
  get closeOnEscape() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnEscape(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get portal() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set portal(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeOnPointerDown() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeOnPointerDown(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get openDelay() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set openDelay(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get closeDelay() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set closeDelay(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get open() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set open(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get onOpenChange() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set onOpenChange(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get disableHoverableContent() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set disableHoverableContent(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get group() {
    throw new Error("<Tooltip>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set group(value) {
    throw new Error("<Tooltip>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tooltip_default = Tooltip;

// node_modules/bits-ui/dist/bits/tooltip/components/tooltip-content.svelte
var file185 = "node_modules/bits-ui/dist/bits/tooltip/components/tooltip-content.svelte";
var get_default_slot_changes_514 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_514 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_414 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_414 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_314 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_314 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_214 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_214 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes_1152 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context_1152 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
var get_default_slot_changes200 = (dirty) => ({ builder: dirty[0] & /*builder*/
256 });
var get_default_slot_context200 = (ctx) => ({ builder: (
  /*builder*/
  ctx[8]
) });
function create_if_block_516(ctx) {
  let div;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_514
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file185, 105, 1, 2419);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[33](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes_514
            ),
            get_default_slot_context_514
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx2[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx2[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[33](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_516.name,
    type: "if",
    source: "(105:16) ",
    ctx
  });
  return block;
}
function create_if_block_416(ctx) {
  let div;
  let builder_action_action;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_414
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file185, 94, 1, 2191);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[32](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_414
            ),
            get_default_slot_context_414
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (div_outro) div_outro.end(1);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[32](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_416.name,
    type: "if",
    source: "(94:33) ",
    ctx
  });
  return block;
}
function create_if_block_316(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_314
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file185, 83, 1, 1949);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[31](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_314
            ),
            get_default_slot_context_314
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        if (!div_intro) {
          add_render_callback(() => {
            div_intro = create_in_transition(
              div,
              /*inTransition*/
              ctx[3],
              /*inTransitionConfig*/
              ctx[4]
            );
            div_intro.start();
          });
        }
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[31](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_316.name,
    type: "if",
    source: "(83:32) ",
    ctx
  });
  return block;
}
function create_if_block_216(ctx) {
  let div;
  let builder_action_action;
  let div_intro;
  let div_outro;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_214
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file185, 71, 1, 1666);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[30](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_214
            ),
            get_default_slot_context_214
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (div_outro) div_outro.end(1);
          div_intro = create_in_transition(
            div,
            /*inTransition*/
            ctx[3],
            /*inTransitionConfig*/
            ctx[4]
          );
          div_intro.start();
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (div_intro) div_intro.invalidate();
      if (local) {
        div_outro = create_out_transition(
          div,
          /*outTransition*/
          ctx[5],
          /*outTransitionConfig*/
          ctx[6]
        );
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[30](null);
      if (detaching && div_outro) div_outro.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_216.name,
    type: "if",
    source: "(71:49) ",
    ctx
  });
  return block;
}
function create_if_block_122(ctx) {
  let div;
  let builder_action_action;
  let div_transition;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context_1152
  );
  let div_levels = [
    /*builder*/
    ctx[8],
    /*$$restProps*/
    ctx[13]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      var div_nodes = children(div);
      if (default_slot) default_slot.l(div_nodes);
      div_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file185, 60, 1, 1404);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      if (default_slot) {
        default_slot.m(div, null);
      }
      ctx[29](div);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[8].action(div)),
          listen_dev(
            div,
            "m-pointerdown",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            div,
            "m-pointerenter",
            /*dispatch*/
            ctx[12],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(new_ctx, dirty) {
      ctx = new_ctx;
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx,
            /*$$scope*/
            ctx[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx[27],
              dirty,
              get_default_slot_changes_1152
            ),
            get_default_slot_context_1152
          );
        }
      }
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty[0] & /*builder*/
        256 && /*builder*/
        ctx[8],
        dirty[0] & /*$$restProps*/
        8192 && /*$$restProps*/
        ctx[13]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      if (local) {
        add_render_callback(() => {
          if (!current) return;
          if (!div_transition) div_transition = create_bidirectional_transition(
            div,
            /*transition*/
            ctx[1],
            /*transitionConfig*/
            ctx[2],
            true
          );
          div_transition.run(1);
        });
      }
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      if (local) {
        if (!div_transition) div_transition = create_bidirectional_transition(
          div,
          /*transition*/
          ctx[1],
          /*transitionConfig*/
          ctx[2],
          false
        );
        div_transition.run(0);
      }
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[29](null);
      if (detaching && div_transition) div_transition.end();
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block_122.name,
    type: "if",
    source: "(60:30) ",
    ctx
  });
  return block;
}
function create_if_block183(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[28].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[27],
    get_default_slot_context200
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty[0] & /*$$scope, builder*/
        134217984)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[27],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[27]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[27],
              dirty,
              get_default_slot_changes200
            ),
            get_default_slot_context200
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block183.name,
    type: "if",
    source: "(58:0) {#if asChild && $open}",
    ctx
  });
  return block;
}
function create_fragment205(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [
    create_if_block183,
    create_if_block_122,
    create_if_block_216,
    create_if_block_316,
    create_if_block_416,
    create_if_block_516
  ];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[7] && /*$open*/
      ctx2[9]
    ) return 0;
    if (
      /*transition*/
      ctx2[1] && /*$open*/
      ctx2[9]
    ) return 1;
    if (
      /*inTransition*/
      ctx2[3] && /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 2;
    if (
      /*inTransition*/
      ctx2[3] && /*$open*/
      ctx2[9]
    ) return 3;
    if (
      /*outTransition*/
      ctx2[5] && /*$open*/
      ctx2[9]
    ) return 4;
    if (
      /*$open*/
      ctx2[9]
    ) return 5;
    return -1;
  }
  if (~(current_block_type_index = select_block_type(ctx, [-1, -1]))) {
    if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  }
  const block = {
    c: function create() {
      if (if_block) if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if (if_block) if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].m(target, anchor);
      }
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, dirty) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if (~current_block_type_index) {
          if_blocks[current_block_type_index].p(ctx2, dirty);
        }
      } else {
        if (if_block) {
          group_outros();
          transition_out(if_blocks[previous_block_index], 1, 1, () => {
            if_blocks[previous_block_index] = null;
          });
          check_outros();
        }
        if (~current_block_type_index) {
          if_block = if_blocks[current_block_type_index];
          if (!if_block) {
            if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
            if_block.c();
          } else {
            if_block.p(ctx2, dirty);
          }
          transition_in(if_block, 1);
          if_block.m(if_block_anchor.parentNode, if_block_anchor);
        } else {
          if_block = null;
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if (~current_block_type_index) {
        if_blocks[current_block_type_index].d(detaching);
      }
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment205.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance205($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = [
    "transition",
    "transitionConfig",
    "inTransition",
    "inTransitionConfig",
    "outTransition",
    "outTransitionConfig",
    "asChild",
    "id",
    "side",
    "align",
    "sideOffset",
    "alignOffset",
    "collisionPadding",
    "avoidCollisions",
    "collisionBoundary",
    "sameWidth",
    "fitViewport",
    "strategy",
    "overlap",
    "el"
  ];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $open;
  let $content;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tooltip_content", slots, ["default"]);
  let { transition = void 0 } = $$props;
  let { transitionConfig = void 0 } = $$props;
  let { inTransition = void 0 } = $$props;
  let { inTransitionConfig = void 0 } = $$props;
  let { outTransition = void 0 } = $$props;
  let { outTransitionConfig = void 0 } = $$props;
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { side = "top" } = $$props;
  let { align = "center" } = $$props;
  let { sideOffset = 0 } = $$props;
  let { alignOffset = 0 } = $$props;
  let { collisionPadding = 8 } = $$props;
  let { avoidCollisions = true } = $$props;
  let { collisionBoundary = void 0 } = $$props;
  let { sameWidth = false } = $$props;
  let { fitViewport = false } = $$props;
  let { strategy = "absolute" } = $$props;
  let { overlap = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { content }, states: { open }, ids, getAttrs: getAttrs2 } = getCtx29();
  validate_store(content, "content");
  component_subscribe($$self, content, (value) => $$invalidate(26, $content = value));
  validate_store(open, "open");
  component_subscribe($$self, open, (value) => $$invalidate(9, $open = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("content");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_1($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_2($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_3($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  function div_binding_4($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(13, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("transition" in $$new_props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$new_props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$new_props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$new_props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$new_props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$new_props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$new_props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$new_props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$new_props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$new_props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$new_props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$new_props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$new_props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$new_props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$new_props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$new_props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$new_props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$new_props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(27, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    createDispatcher,
    getCtx: getCtx29,
    updatePositioning: updatePositioning10,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    el,
    content,
    open,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $open,
    $content
  });
  $$self.$inject_state = ($$new_props) => {
    if ("transition" in $$props) $$invalidate(1, transition = $$new_props.transition);
    if ("transitionConfig" in $$props) $$invalidate(2, transitionConfig = $$new_props.transitionConfig);
    if ("inTransition" in $$props) $$invalidate(3, inTransition = $$new_props.inTransition);
    if ("inTransitionConfig" in $$props) $$invalidate(4, inTransitionConfig = $$new_props.inTransitionConfig);
    if ("outTransition" in $$props) $$invalidate(5, outTransition = $$new_props.outTransition);
    if ("outTransitionConfig" in $$props) $$invalidate(6, outTransitionConfig = $$new_props.outTransitionConfig);
    if ("asChild" in $$props) $$invalidate(7, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(14, id = $$new_props.id);
    if ("side" in $$props) $$invalidate(15, side = $$new_props.side);
    if ("align" in $$props) $$invalidate(16, align = $$new_props.align);
    if ("sideOffset" in $$props) $$invalidate(17, sideOffset = $$new_props.sideOffset);
    if ("alignOffset" in $$props) $$invalidate(18, alignOffset = $$new_props.alignOffset);
    if ("collisionPadding" in $$props) $$invalidate(19, collisionPadding = $$new_props.collisionPadding);
    if ("avoidCollisions" in $$props) $$invalidate(20, avoidCollisions = $$new_props.avoidCollisions);
    if ("collisionBoundary" in $$props) $$invalidate(21, collisionBoundary = $$new_props.collisionBoundary);
    if ("sameWidth" in $$props) $$invalidate(22, sameWidth = $$new_props.sameWidth);
    if ("fitViewport" in $$props) $$invalidate(23, fitViewport = $$new_props.fitViewport);
    if ("strategy" in $$props) $$invalidate(24, strategy = $$new_props.strategy);
    if ("overlap" in $$props) $$invalidate(25, overlap = $$new_props.overlap);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(8, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty[0] & /*id*/
    16384) {
      $: if (id) {
        ids.content.set(id);
      }
    }
    if ($$self.$$.dirty[0] & /*$content*/
    67108864) {
      $: $$invalidate(8, builder = $content);
    }
    if ($$self.$$.dirty[0] & /*builder*/
    256) {
      $: Object.assign(builder, attrs);
    }
    if ($$self.$$.dirty[0] & /*$open, side, align, sideOffset, alignOffset, collisionPadding, avoidCollisions, collisionBoundary, sameWidth, fitViewport, strategy, overlap*/
    67076608) {
      $: if ($open) {
        updatePositioning10({
          side,
          align,
          sideOffset,
          alignOffset,
          collisionPadding,
          avoidCollisions,
          collisionBoundary,
          sameWidth,
          fitViewport,
          strategy,
          overlap
        });
      }
    }
  };
  return [
    el,
    transition,
    transitionConfig,
    inTransition,
    inTransitionConfig,
    outTransition,
    outTransitionConfig,
    asChild,
    builder,
    $open,
    content,
    open,
    dispatch,
    $$restProps,
    id,
    side,
    align,
    sideOffset,
    alignOffset,
    collisionPadding,
    avoidCollisions,
    collisionBoundary,
    sameWidth,
    fitViewport,
    strategy,
    overlap,
    $content,
    $$scope,
    slots,
    div_binding,
    div_binding_1,
    div_binding_2,
    div_binding_3,
    div_binding_4
  ];
}
var Tooltip_content = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(
      this,
      options,
      instance205,
      create_fragment205,
      safe_not_equal,
      {
        transition: 1,
        transitionConfig: 2,
        inTransition: 3,
        inTransitionConfig: 4,
        outTransition: 5,
        outTransitionConfig: 6,
        asChild: 7,
        id: 14,
        side: 15,
        align: 16,
        sideOffset: 17,
        alignOffset: 18,
        collisionPadding: 19,
        avoidCollisions: 20,
        collisionBoundary: 21,
        sameWidth: 22,
        fitViewport: 23,
        strategy: 24,
        overlap: 25,
        el: 0
      },
      null,
      [-1, -1]
    );
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tooltip_content",
      options,
      id: create_fragment205.name
    });
  }
  get transition() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transition(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get transitionConfig() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set transitionConfig(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransition() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransition(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get inTransitionConfig() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set inTransitionConfig(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransition() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransition(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get outTransitionConfig() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set outTransitionConfig(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get side() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set side(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get align() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set align(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sideOffset() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sideOffset(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get alignOffset() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set alignOffset(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionPadding() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionPadding(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get avoidCollisions() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set avoidCollisions(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get collisionBoundary() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set collisionBoundary(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get sameWidth() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set sameWidth(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get fitViewport() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set fitViewport(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get strategy() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set strategy(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get overlap() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set overlap(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Tooltip_content>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Tooltip_content>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tooltip_content_default = Tooltip_content;

// node_modules/bits-ui/dist/bits/tooltip/components/tooltip-trigger.svelte
var file186 = "node_modules/bits-ui/dist/bits/tooltip/components/tooltip-trigger.svelte";
var get_default_slot_changes_1153 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context_1153 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
var get_default_slot_changes201 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context201 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block168(ctx) {
  let button;
  let builder_action_action;
  let current;
  let mounted;
  let dispose;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context_1153
  );
  let button_levels = [
    /*builder*/
    ctx[2],
    { type: "button" },
    /*$$restProps*/
    ctx[5]
  ];
  let button_data = {};
  for (let i = 0; i < button_levels.length; i += 1) {
    button_data = assign(button_data, button_levels[i]);
  }
  const block = {
    c: function create() {
      button = element("button");
      if (default_slot) default_slot.c();
      this.h();
    },
    l: function claim(nodes) {
      button = claim_element(nodes, "BUTTON", { type: true });
      var button_nodes = children(button);
      if (default_slot) default_slot.l(button_nodes);
      button_nodes.forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(button, button_data);
      add_location(button, file186, 26, 1, 519);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, button, anchor);
      if (default_slot) {
        default_slot.m(button, null);
      }
      if (button.autofocus) button.focus();
      ctx[10](button);
      current = true;
      if (!mounted) {
        dispose = [
          action_destroyer(builder_action_action = /*builder*/
          ctx[2].action(button)),
          listen_dev(
            button,
            "m-blur",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-focus",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-keydown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-pointerdown",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-pointerenter",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          ),
          listen_dev(
            button,
            "m-pointerleave",
            /*dispatch*/
            ctx[4],
            false,
            false,
            false,
            false
          )
        ];
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes_1153
            ),
            get_default_slot_context_1153
          );
        }
      }
      set_attributes(button, button_data = get_spread_update(button_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        { type: "button" },
        dirty & /*$$restProps*/
        32 && /*$$restProps*/
        ctx2[5]
      ]));
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(button);
      }
      if (default_slot) default_slot.d(detaching);
      ctx[10](null);
      mounted = false;
      run_all(dispose);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block168.name,
    type: "else",
    source: "(26:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block184(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[9].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[8],
    get_default_slot_context201
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        260)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[8],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[8]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[8],
              dirty,
              get_default_slot_changes201
            ),
            get_default_slot_context201
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block184.name,
    type: "if",
    source: "(24:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment206(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block184, create_else_block168];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment206.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance206($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["asChild", "id", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $trigger;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tooltip_trigger", slots, ["default"]);
  let { asChild = false } = $$props;
  let { id = void 0 } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { trigger }, ids, getAttrs: getAttrs2 } = getCtx29();
  validate_store(trigger, "trigger");
  component_subscribe($$self, trigger, (value) => $$invalidate(7, $trigger = value));
  const dispatch = createDispatcher();
  const attrs = getAttrs2("trigger");
  function button_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(5, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$new_props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(8, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    createDispatcher,
    getCtx: getCtx29,
    asChild,
    id,
    el,
    trigger,
    ids,
    getAttrs: getAttrs2,
    dispatch,
    attrs,
    builder,
    $trigger
  });
  $$self.$inject_state = ($$new_props) => {
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("id" in $$props) $$invalidate(6, id = $$new_props.id);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*id*/
    64) {
      $: if (id) {
        ids.trigger.set(id);
      }
    }
    if ($$self.$$.dirty & /*$trigger*/
    128) {
      $: $$invalidate(2, builder = $trigger);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    trigger,
    dispatch,
    $$restProps,
    id,
    $trigger,
    $$scope,
    slots,
    button_binding
  ];
}
var Tooltip_trigger = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance206, create_fragment206, safe_not_equal, { asChild: 1, id: 6, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tooltip_trigger",
      options,
      id: create_fragment206.name
    });
  }
  get asChild() {
    throw new Error("<Tooltip_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Tooltip_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get id() {
    throw new Error("<Tooltip_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set id(value) {
    throw new Error("<Tooltip_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Tooltip_trigger>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Tooltip_trigger>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tooltip_trigger_default = Tooltip_trigger;

// node_modules/bits-ui/dist/bits/tooltip/components/tooltip-arrow.svelte
var file187 = "node_modules/bits-ui/dist/bits/tooltip/components/tooltip-arrow.svelte";
var get_default_slot_changes202 = (dirty) => ({ builder: dirty & /*builder*/
4 });
var get_default_slot_context202 = (ctx) => ({ builder: (
  /*builder*/
  ctx[2]
) });
function create_else_block169(ctx) {
  let div;
  let builder_action_action;
  let mounted;
  let dispose;
  let div_levels = [
    /*builder*/
    ctx[2],
    /*$$restProps*/
    ctx[4]
  ];
  let div_data = {};
  for (let i = 0; i < div_levels.length; i += 1) {
    div_data = assign(div_data, div_levels[i]);
  }
  const block = {
    c: function create() {
      div = element("div");
      this.h();
    },
    l: function claim(nodes) {
      div = claim_element(nodes, "DIV", {});
      children(div).forEach(detach_dev);
      this.h();
    },
    h: function hydrate() {
      set_attributes(div, div_data);
      add_location(div, file187, 19, 1, 367);
    },
    m: function mount(target, anchor) {
      insert_hydration_dev(target, div, anchor);
      ctx[9](div);
      if (!mounted) {
        dispose = action_destroyer(builder_action_action = /*builder*/
        ctx[2].action(div));
        mounted = true;
      }
    },
    p: function update(ctx2, dirty) {
      set_attributes(div, div_data = get_spread_update(div_levels, [
        dirty & /*builder*/
        4 && /*builder*/
        ctx2[2],
        dirty & /*$$restProps*/
        16 && /*$$restProps*/
        ctx2[4]
      ]));
    },
    i: noop,
    o: noop,
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(div);
      }
      ctx[9](null);
      mounted = false;
      dispose();
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_else_block169.name,
    type: "else",
    source: "(19:0) {:else}",
    ctx
  });
  return block;
}
function create_if_block185(ctx) {
  let current;
  const default_slot_template = (
    /*#slots*/
    ctx[8].default
  );
  const default_slot = create_slot(
    default_slot_template,
    ctx,
    /*$$scope*/
    ctx[7],
    get_default_slot_context202
  );
  const block = {
    c: function create() {
      if (default_slot) default_slot.c();
    },
    l: function claim(nodes) {
      if (default_slot) default_slot.l(nodes);
    },
    m: function mount(target, anchor) {
      if (default_slot) {
        default_slot.m(target, anchor);
      }
      current = true;
    },
    p: function update(ctx2, dirty) {
      if (default_slot) {
        if (default_slot.p && (!current || dirty & /*$$scope, builder*/
        132)) {
          update_slot_base(
            default_slot,
            default_slot_template,
            ctx2,
            /*$$scope*/
            ctx2[7],
            !current ? get_all_dirty_from_scope(
              /*$$scope*/
              ctx2[7]
            ) : get_slot_changes(
              default_slot_template,
              /*$$scope*/
              ctx2[7],
              dirty,
              get_default_slot_changes202
            ),
            get_default_slot_context202
          );
        }
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(default_slot, local);
      current = true;
    },
    o: function outro(local) {
      transition_out(default_slot, local);
      current = false;
    },
    d: function destroy(detaching) {
      if (default_slot) default_slot.d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_if_block185.name,
    type: "if",
    source: "(17:0) {#if asChild}",
    ctx
  });
  return block;
}
function create_fragment207(ctx) {
  let current_block_type_index;
  let if_block;
  let if_block_anchor;
  let current;
  const if_block_creators = [create_if_block185, create_else_block169];
  const if_blocks = [];
  function select_block_type(ctx2, dirty) {
    if (
      /*asChild*/
      ctx2[1]
    ) return 0;
    return 1;
  }
  current_block_type_index = select_block_type(ctx, -1);
  if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
  const block = {
    c: function create() {
      if_block.c();
      if_block_anchor = empty();
    },
    l: function claim(nodes) {
      if_block.l(nodes);
      if_block_anchor = empty();
    },
    m: function mount(target, anchor) {
      if_blocks[current_block_type_index].m(target, anchor);
      insert_hydration_dev(target, if_block_anchor, anchor);
      current = true;
    },
    p: function update(ctx2, [dirty]) {
      let previous_block_index = current_block_type_index;
      current_block_type_index = select_block_type(ctx2, dirty);
      if (current_block_type_index === previous_block_index) {
        if_blocks[current_block_type_index].p(ctx2, dirty);
      } else {
        group_outros();
        transition_out(if_blocks[previous_block_index], 1, 1, () => {
          if_blocks[previous_block_index] = null;
        });
        check_outros();
        if_block = if_blocks[current_block_type_index];
        if (!if_block) {
          if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx2);
          if_block.c();
        } else {
          if_block.p(ctx2, dirty);
        }
        transition_in(if_block, 1);
        if_block.m(if_block_anchor.parentNode, if_block_anchor);
      }
    },
    i: function intro(local) {
      if (current) return;
      transition_in(if_block);
      current = true;
    },
    o: function outro(local) {
      transition_out(if_block);
      current = false;
    },
    d: function destroy(detaching) {
      if (detaching) {
        detach_dev(if_block_anchor);
      }
      if_blocks[current_block_type_index].d(detaching);
    }
  };
  dispatch_dev("SvelteRegisterBlock", {
    block,
    id: create_fragment207.name,
    type: "component",
    source: "",
    ctx
  });
  return block;
}
function instance207($$self, $$props, $$invalidate) {
  let builder;
  const omit_props_names = ["size", "asChild", "el"];
  let $$restProps = compute_rest_props($$props, omit_props_names);
  let $arrow;
  let { $$slots: slots = {}, $$scope } = $$props;
  validate_slots("Tooltip_arrow", slots, ["default"]);
  let { size: size3 = 8 } = $$props;
  let { asChild = false } = $$props;
  let { el = void 0 } = $$props;
  const { elements: { arrow: arrow3 }, getAttrs: getAttrs2 } = setArrow6(size3);
  validate_store(arrow3, "arrow");
  component_subscribe($$self, arrow3, (value) => $$invalidate(6, $arrow = value));
  const attrs = getAttrs2("arrow");
  function div_binding($$value) {
    binding_callbacks[$$value ? "unshift" : "push"](() => {
      el = $$value;
      $$invalidate(0, el);
    });
  }
  $$self.$$set = ($$new_props) => {
    $$props = assign(assign({}, $$props), exclude_internal_props($$new_props));
    $$invalidate(4, $$restProps = compute_rest_props($$props, omit_props_names));
    if ("size" in $$new_props) $$invalidate(5, size3 = $$new_props.size);
    if ("asChild" in $$new_props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$new_props) $$invalidate(0, el = $$new_props.el);
    if ("$$scope" in $$new_props) $$invalidate(7, $$scope = $$new_props.$$scope);
  };
  $$self.$capture_state = () => ({
    melt,
    setArrow: setArrow6,
    size: size3,
    asChild,
    el,
    arrow: arrow3,
    getAttrs: getAttrs2,
    attrs,
    builder,
    $arrow
  });
  $$self.$inject_state = ($$new_props) => {
    if ("size" in $$props) $$invalidate(5, size3 = $$new_props.size);
    if ("asChild" in $$props) $$invalidate(1, asChild = $$new_props.asChild);
    if ("el" in $$props) $$invalidate(0, el = $$new_props.el);
    if ("builder" in $$props) $$invalidate(2, builder = $$new_props.builder);
  };
  if ($$props && "$$inject" in $$props) {
    $$self.$inject_state($$props.$$inject);
  }
  $$self.$$.update = () => {
    if ($$self.$$.dirty & /*$arrow*/
    64) {
      $: $$invalidate(2, builder = $arrow);
    }
    if ($$self.$$.dirty & /*builder*/
    4) {
      $: Object.assign(builder, attrs);
    }
  };
  return [
    el,
    asChild,
    builder,
    arrow3,
    $$restProps,
    size3,
    $arrow,
    $$scope,
    slots,
    div_binding
  ];
}
var Tooltip_arrow = class extends SvelteComponentDev {
  constructor(options) {
    super(options);
    init(this, options, instance207, create_fragment207, safe_not_equal, { size: 5, asChild: 1, el: 0 });
    dispatch_dev("SvelteRegisterComponent", {
      component: this,
      tagName: "Tooltip_arrow",
      options,
      id: create_fragment207.name
    });
  }
  get size() {
    throw new Error("<Tooltip_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set size(value) {
    throw new Error("<Tooltip_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get asChild() {
    throw new Error("<Tooltip_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set asChild(value) {
    throw new Error("<Tooltip_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  get el() {
    throw new Error("<Tooltip_arrow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
  set el(value) {
    throw new Error("<Tooltip_arrow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
  }
};
var tooltip_arrow_default = Tooltip_arrow;
export {
  accordion_exports as Accordion,
  alert_dialog_exports as AlertDialog,
  aspect_ratio_exports as AspectRatio,
  avatar_exports as Avatar,
  button_exports as Button,
  calendar_exports as Calendar,
  checkbox_exports as Checkbox,
  collapsible_exports as Collapsible,
  combobox_exports as Combobox,
  context_menu_exports as ContextMenu,
  date_field_exports as DateField,
  date_picker_exports as DatePicker,
  date_range_field_exports as DateRangeField,
  date_range_picker_exports as DateRangePicker,
  dialog_exports as Dialog,
  dropdown_menu_exports as DropdownMenu,
  label_exports as Label,
  link_preview_exports as LinkPreview,
  menubar_exports as Menubar,
  pagination_exports as Pagination,
  pin_input_exports as PinInput,
  popover_exports as Popover,
  progress_exports as Progress,
  radio_group_exports as RadioGroup,
  range_calendar_exports as RangeCalendar,
  scroll_area_exports as ScrollArea,
  select_exports as Select,
  separator_exports as Separator,
  slider_exports as Slider,
  switch_exports as Switch,
  tabs_exports as Tabs,
  toggle_exports as Toggle,
  toggle_group_exports as ToggleGroup,
  toolbar_exports as Toolbar,
  tooltip_exports as Tooltip,
  builderActions,
  getAttrs
};
/*! Bundled license information:

tabbable/dist/index.esm.js:
  (*!
  * tabbable 6.2.0
  * @license MIT, https://github.com/focus-trap/tabbable/blob/master/LICENSE
  *)

focus-trap/dist/focus-trap.esm.js:
  (*!
  * focus-trap 7.5.4
  * @license MIT, https://github.com/focus-trap/focus-trap/blob/master/LICENSE
  *)
*/
//# sourceMappingURL=bits-ui.js.map