cisse-vue-ui 0.5.21 → 0.5.23

package/dist/composables/useFocusTrap.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from 'vue';
+export interface UseFocusTrapOptions {
+    /** Whether the focus trap is active */
+    active?: Ref<boolean> | boolean;
+    /** Focus the first focusable element when trap activates */
+    focusFirst?: boolean;
+    /** Restore focus to the previously focused element when trap deactivates */
+    restoreFocus?: boolean;
+    /** Initial element to focus (selector or element) */
+    initialFocus?: string | HTMLElement | null;
+}
+export interface UseFocusTrapReturn {
+    /** Ref to attach to the container element */
+    containerRef: Ref<HTMLElement | null>;
+    /** Activate the focus trap manually */
+    activate: () => void;
+    /** Deactivate the focus trap manually */
+    deactivate: () => void;
+    /** Whether the focus trap is currently active */
+    isActive: Ref<boolean>;
+}
+/**
+ * Composable for trapping focus within a container element (for modals, dialogs, etc.)
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const isOpen = ref(false)
+ * const { containerRef } = useFocusTrap({ active: isOpen })
+ * </script>
+ *
+ * <template>
+ *   <div v-if="isOpen" ref="containerRef" role="dialog">
+ *     <button>First focusable</button>
+ *     <input type="text" />
+ *     <button @click="isOpen = false">Close</button>
+ *   </div>
+ * </template>
+ * ```
+ */
+export declare function useFocusTrap(options?: UseFocusTrapOptions): UseFocusTrapReturn;

package/dist/composables/useFocusTrap.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/useId.d.ts

@@ -0,0 +1,42 @@
+import { Ref } from 'vue';
+/**
+ * Generates a unique ID for accessibility relationships (aria-labelledby, aria-describedby, etc.)
+ * Pattern: cisse-{prefix}-{counter}
+ */
+export declare function generateId(prefix?: string): string;
+/**
+ * Resets the ID counter (useful for testing)
+ */
+export declare function resetIdCounter(): void;
+export interface UseIdOptions {
+    /** Prefix for the generated ID */
+    prefix?: string;
+    /** Custom ID to use instead of generating one */
+    id?: string;
+}
+export interface UseIdReturn {
+    /** The unique ID (reactive) */
+    id: Ref<string>;
+    /** Generate a related ID with a suffix (e.g., id-label, id-description) */
+    related: (suffix: string) => string;
+}
+/**
+ * Composable for generating unique IDs for accessibility relationships
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const { id, related } = useId({ prefix: 'modal' })
+ * // id.value = 'cisse-modal-1'
+ * // related('title') = 'cisse-modal-1-title'
+ * // related('description') = 'cisse-modal-1-description'
+ * </script>
+ *
+ * <template>
+ *   <div :id="id" role="dialog" :aria-labelledby="related('title')">
+ *     <h2 :id="related('title')">Modal Title</h2>
+ *   </div>
+ * </template>
+ * ```
+ */
+export declare function useId(options?: UseIdOptions): UseIdReturn;

package/dist/composables/useId.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/composables/useModal.d.ts

@@ -57,4 +57,4 @@ export declare function useModal<T = unknown>(options?: {
  * modals.delete.close()
  * ```
  */
-export declare function useModals<T extends Record<string, UseModalReturn<unknown>>>(modals: T): T;
+export declare function useModals<T extends Record<string, UseModalReturn<any>>>(modals: T): T;

package/dist/composables/useModal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index-BMoLBt6A.js

@@ -0,0 +1,75 @@
+import { o as _sfc_main, p as _sfc_main$1, d as _sfc_main$3, f as _sfc_main$4, n as _sfc_main$8, _ as _sfc_main$a, j as _sfc_main$d, r as _sfc_main$h, m as _sfc_main$k, b as _sfc_main$w, l as _sfc_main$D, c as _sfc_main$G, i as _sfc_main$K, h as _sfc_main$M, e as _sfc_main$N, a as _sfc_main$O, g as _sfc_main$Q, q as _sfc_main$S, k as _sfc_main$V } from "./DarkModeToggle.vue_vue_type_script_setup_true_lang-D1Q43mhJ.js";
+import { a as _sfc_main$l, _ as _sfc_main$v } from "./Dropdown.vue_vue_type_script_setup_true_lang-DXV811zB.js";
+import { e as _sfc_main$5, d as _sfc_main$7, c as _sfc_main$j, b as _sfc_main$A, _ as _sfc_main$J, a as _sfc_main$R } from "./BadgeType.vue_vue_type_script_setup_true_lang-CnB5eNEM.js";
+import { _ as _sfc_main$9, b as _sfc_main$b, c as _sfc_main$t, a as _sfc_main$P } from "./Button.vue_vue_type_script_setup_true_lang-CD9QPOeU.js";
+import { j as _sfc_main$e, l as _sfc_main$f, g as _sfc_main$i, h as _sfc_main$n, d as _sfc_main$o, a as _sfc_main$p, b as _sfc_main$q, _ as _sfc_main$r, c as _sfc_main$s, k as _sfc_main$E, i as _sfc_main$F, e as _sfc_main$H, S as Slider, f as _sfc_main$L } from "./Combobox.vue_vue_type_script_setup_true_lang-DCLKWzhc.js";
+import { _ as _sfc_main$c } from "./index-CJwlO351.js";
+import { e as _sfc_main$2, j as _sfc_main$g, f as _sfc_main$m, _ as _sfc_main$u, a as _sfc_main$x, c as _sfc_main$y, d as _sfc_main$z, b as _sfc_main$C, P as Progress, i as _sfc_main$I, g as _sfc_main$T, h as _sfc_main$U } from "./ConfirmDialog.vue_vue_type_script_setup_true_lang-Dm4kLAnr.js";
+import { _ as _sfc_main$6, a as _sfc_main$B } from "./PageLayout.vue_vue_type_script_setup_true_lang-ClzYGS8h.js";
+const components = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Accordion: _sfc_main,
+  AccordionItem: _sfc_main$1,
+  Alert: _sfc_main$2,
+  AutocompleteComponent: _sfc_main$3,
+  Avatar: _sfc_main$4,
+  BadgeType: _sfc_main$5,
+  BaseLayout: _sfc_main$6,
+  BooleanType: _sfc_main$7,
+  Breadcrumb: _sfc_main$8,
+  Button: _sfc_main$9,
+  CardComponent: _sfc_main$a,
+  CardSkeleton: _sfc_main$b,
+  Checkbox: _sfc_main$c,
+  CollapsibleCard: _sfc_main$d,
+  ColorPicker: _sfc_main$e,
+  Combobox: _sfc_main$f,
+  ConfirmDialog: _sfc_main$g,
+  DarkModeToggle: _sfc_main$h,
+  DatePicker: _sfc_main$i,
+  DateType: _sfc_main$j,
+  Drawer: _sfc_main$k,
+  Dropdown: _sfc_main$l,
+  EmptyState: _sfc_main$m,
+  FileUpload: _sfc_main$n,
+  FormGroup: _sfc_main$o,
+  FormHelp: _sfc_main$p,
+  FormInput: _sfc_main$q,
+  FormLabel: _sfc_main$r,
+  FormSelect: _sfc_main$s,
+  ListSkeleton: _sfc_main$t,
+  LoadingSpinner: _sfc_main$u,
+  MenuItem: _sfc_main$v,
+  MobileList: _sfc_main$w,
+  Modal: _sfc_main$x,
+  NotificationComponent: _sfc_main$y,
+  NotificationList: _sfc_main$z,
+  NumberType: _sfc_main$A,
+  PageLayout: _sfc_main$B,
+  PaginationControls: _sfc_main$C,
+  Popover: _sfc_main$D,
+  Progress,
+  RangeSlider: _sfc_main$E,
+  Rating: _sfc_main$F,
+  ResponsiveList: _sfc_main$G,
+  SearchInput: _sfc_main$H,
+  Skeleton: _sfc_main$I,
+  Slider,
+  StatusBadge: _sfc_main$J,
+  Stepper: _sfc_main$K,
+  Switch: _sfc_main$L,
+  TabPanel: _sfc_main$M,
+  TableAction: _sfc_main$N,
+  TableComponent: _sfc_main$O,
+  TableSkeleton: _sfc_main$P,
+  Tabs: _sfc_main$Q,
+  TextType: _sfc_main$R,
+  Timeline: _sfc_main$S,
+  Toast: _sfc_main$T,
+  ToastContainer: _sfc_main$U,
+  Tooltip: _sfc_main$V
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  components as c
+};
+//# sourceMappingURL=index-BMoLBt6A.js.map

package/dist/index-BMoLBt6A.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BMoLBt6A.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/index-CJwlO351.js

@@ -0,0 +1,347 @@
+import { defineComponent, computed, createElementBlock, openBlock, normalizeClass, createElementVNode, createCommentVNode, toDisplayString, onMounted, nextTick, getCurrentInstance, getCurrentScope, hasInjectionContext, inject, watch, shallowRef, toValue, watchEffect, unref } from "vue";
+import { u as useId } from "./useId-xeHj7rkg.js";
+const _hoisted_1 = ["id", "checked", "disabled", "indeterminate", "aria-describedby"];
+const _hoisted_2 = {
+  key: 0,
+  class: "flex flex-col"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "text-sm font-medium text-gray-900 dark:text-white"
+};
+const _hoisted_4 = ["id"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "Checkbox",
+  props: {
+    modelValue: { type: Boolean, default: false },
+    label: {},
+    description: {},
+    disabled: { type: Boolean },
+    indeterminate: { type: Boolean },
+    id: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const { id: generatedId, related } = useId({ prefix: "checkbox", id: props.id });
+    const inputId = computed(() => props.id ?? generatedId.value);
+    const descriptionId = computed(() => related("description"));
+    const toggle = (event) => {
+      const target = event.target;
+      emit("update:modelValue", target.checked);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("label", {
+        class: normalizeClass(["inline-flex items-start gap-3", __props.disabled ? "cursor-not-allowed opacity-50" : "cursor-pointer"])
+      }, [
+        createElementVNode("input", {
+          id: inputId.value,
+          type: "checkbox",
+          checked: __props.modelValue,
+          disabled: __props.disabled,
+          indeterminate: __props.indeterminate,
+          "aria-describedby": __props.description ? descriptionId.value : void 0,
+          class: "mt-0.5 size-4 rounded border-gray-300 text-primary/90 focus:ring-2 focus:ring-primary focus:ring-offset-2 disabled:cursor-not-allowed dark:border-gray-600 dark:bg-gray-800 dark:focus:ring-offset-gray-900",
+          onChange: toggle
+        }, null, 40, _hoisted_1),
+        __props.label || __props.description ? (openBlock(), createElementBlock("div", _hoisted_2, [
+          __props.label ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(__props.label), 1)) : createCommentVNode("", true),
+          __props.description ? (openBlock(), createElementBlock("span", {
+            key: 1,
+            id: descriptionId.value,
+            class: "text-sm text-gray-500 dark:text-gray-400"
+          }, toDisplayString(__props.description), 9, _hoisted_4)) : createCommentVNode("", true)
+        ])) : createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+const localProvidedStateMap = /* @__PURE__ */ new WeakMap();
+const injectLocal = /* @__NO_SIDE_EFFECTS__ */ (...args) => {
+  var _getCurrentInstance;
+  const key = args[0];
+  const instance = (_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy;
+  const owner = instance !== null && instance !== void 0 ? instance : getCurrentScope();
+  if (owner == null && !hasInjectionContext()) throw new Error("injectLocal must be called in setup");
+  if (owner && localProvidedStateMap.has(owner) && key in localProvidedStateMap.get(owner)) return localProvidedStateMap.get(owner)[key];
+  return inject(...args);
+};
+const isClient = typeof window !== "undefined" && typeof document !== "undefined";
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const toString = Object.prototype.toString;
+const isObject = (val) => toString.call(val) === "[object Object]";
+const noop = () => {
+};
+function increaseWithUnit(target, delta) {
+  var _target$match;
+  if (typeof target === "number") return target + delta;
+  const value = ((_target$match = target.match(/^-?\d+\.?\d*/)) === null || _target$match === void 0 ? void 0 : _target$match[0]) || "";
+  const unit = target.slice(value.length);
+  const result = Number.parseFloat(value) + delta;
+  if (Number.isNaN(result)) return target;
+  return result + unit;
+}
+function pxValue(px) {
+  return px.endsWith("rem") ? Number.parseFloat(px) * 16 : Number.parseFloat(px);
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function getLifeCycleTarget(target) {
+  return getCurrentInstance();
+}
+function tryOnMounted(fn, sync = true, target) {
+  if (getLifeCycleTarget()) onMounted(fn, target);
+  else if (sync) fn();
+  else nextTick(fn);
+}
+function watchImmediate(source, cb, options) {
+  return watch(source, cb, {
+    ...options,
+    immediate: true
+  });
+}
+const defaultWindow = isClient ? window : void 0;
+function unrefElement(elRef) {
+  var _$el;
+  const plain = toValue(elRef);
+  return (_$el = plain === null || plain === void 0 ? void 0 : plain.$el) !== null && _$el !== void 0 ? _$el : plain;
+}
+function useEventListener(...args) {
+  const register = (el, event, listener, options) => {
+    el.addEventListener(event, listener, options);
+    return () => el.removeEventListener(event, listener, options);
+  };
+  const firstParamTargets = computed(() => {
+    const test = toArray(toValue(args[0])).filter((e) => e != null);
+    return test.every((e) => typeof e !== "string") ? test : void 0;
+  });
+  return watchImmediate(() => {
+    var _firstParamTargets$va, _firstParamTargets$va2;
+    return [
+      (_firstParamTargets$va = (_firstParamTargets$va2 = firstParamTargets.value) === null || _firstParamTargets$va2 === void 0 ? void 0 : _firstParamTargets$va2.map((e) => unrefElement(e))) !== null && _firstParamTargets$va !== void 0 ? _firstParamTargets$va : [defaultWindow].filter((e) => e != null),
+      toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
+      toArray(unref(firstParamTargets.value ? args[2] : args[1])),
+      toValue(firstParamTargets.value ? args[3] : args[2])
+    ];
+  }, ([raw_targets, raw_events, raw_listeners, raw_options], _, onCleanup) => {
+    if (!(raw_targets === null || raw_targets === void 0 ? void 0 : raw_targets.length) || !(raw_events === null || raw_events === void 0 ? void 0 : raw_events.length) || !(raw_listeners === null || raw_listeners === void 0 ? void 0 : raw_listeners.length)) return;
+    const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+    const cleanups = raw_targets.flatMap((el) => raw_events.flatMap((event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))));
+    onCleanup(() => {
+      cleanups.forEach((fn) => fn());
+    });
+  }, { flush: "post" });
+}
+function onClickOutside(target, handler, options = {}) {
+  const { window: window$1 = defaultWindow, ignore = [], capture = true, detectIframe = false, controls = false } = options;
+  if (!window$1) return controls ? {
+    stop: noop,
+    cancel: noop,
+    trigger: noop
+  } : noop;
+  let shouldListen = true;
+  const shouldIgnore = (event) => {
+    return toValue(ignore).some((target$1) => {
+      if (typeof target$1 === "string") return Array.from(window$1.document.querySelectorAll(target$1)).some((el) => el === event.target || event.composedPath().includes(el));
+      else {
+        const el = unrefElement(target$1);
+        return el && (event.target === el || event.composedPath().includes(el));
+      }
+    });
+  };
+  function hasMultipleRoots(target$1) {
+    const vm = toValue(target$1);
+    return vm && vm.$.subTree.shapeFlag === 16;
+  }
+  function checkMultipleRoots(target$1, event) {
+    const vm = toValue(target$1);
+    const children = vm.$.subTree && vm.$.subTree.children;
+    if (children == null || !Array.isArray(children)) return false;
+    return children.some((child) => child.el === event.target || event.composedPath().includes(child.el));
+  }
+  const listener = (event) => {
+    const el = unrefElement(target);
+    if (event.target == null) return;
+    if (!(el instanceof Element) && hasMultipleRoots(target) && checkMultipleRoots(target, event)) return;
+    if (!el || el === event.target || event.composedPath().includes(el)) return;
+    if ("detail" in event && event.detail === 0) shouldListen = !shouldIgnore(event);
+    if (!shouldListen) {
+      shouldListen = true;
+      return;
+    }
+    handler(event);
+  };
+  let isProcessingClick = false;
+  const cleanup = [
+    useEventListener(window$1, "click", (event) => {
+      if (!isProcessingClick) {
+        isProcessingClick = true;
+        setTimeout(() => {
+          isProcessingClick = false;
+        }, 0);
+        listener(event);
+      }
+    }, {
+      passive: true,
+      capture
+    }),
+    useEventListener(window$1, "pointerdown", (e) => {
+      const el = unrefElement(target);
+      shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));
+    }, { passive: true }),
+    detectIframe && useEventListener(window$1, "blur", (event) => {
+      setTimeout(() => {
+        var _window$document$acti;
+        const el = unrefElement(target);
+        if (((_window$document$acti = window$1.document.activeElement) === null || _window$document$acti === void 0 ? void 0 : _window$document$acti.tagName) === "IFRAME" && !(el === null || el === void 0 ? void 0 : el.contains(window$1.document.activeElement))) handler(event);
+      }, 0);
+    }, { passive: true })
+  ].filter(Boolean);
+  const stop = () => cleanup.forEach((fn) => fn());
+  if (controls) return {
+    stop,
+    cancel: () => {
+      shouldListen = false;
+    },
+    trigger: (event) => {
+      shouldListen = true;
+      listener(event);
+      shouldListen = false;
+    }
+  };
+  return stop;
+}
+// @__NO_SIDE_EFFECTS__
+function useMounted() {
+  const isMounted = shallowRef(false);
+  const instance = getCurrentInstance();
+  if (instance) onMounted(() => {
+    isMounted.value = true;
+  }, instance);
+  return isMounted;
+}
+// @__NO_SIDE_EFFECTS__
+function useSupported(callback) {
+  const isMounted = /* @__PURE__ */ useMounted();
+  return computed(() => {
+    isMounted.value;
+    return Boolean(callback());
+  });
+}
+const ssrWidthSymbol = Symbol("vueuse-ssr-width");
+// @__NO_SIDE_EFFECTS__
+function useSSRWidth() {
+  const ssrWidth = hasInjectionContext() ? /* @__PURE__ */ injectLocal(ssrWidthSymbol, null) : null;
+  return typeof ssrWidth === "number" ? ssrWidth : void 0;
+}
+function useMediaQuery(query, options = {}) {
+  const { window: window$1 = defaultWindow, ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
+  const isSupported = /* @__PURE__ */ useSupported(() => window$1 && "matchMedia" in window$1 && typeof window$1.matchMedia === "function");
+  const ssrSupport = shallowRef(typeof ssrWidth === "number");
+  const mediaQuery = shallowRef();
+  const matches = shallowRef(false);
+  const handler = (event) => {
+    matches.value = event.matches;
+  };
+  watchEffect(() => {
+    if (ssrSupport.value) {
+      ssrSupport.value = !isSupported.value;
+      matches.value = toValue(query).split(",").some((queryString) => {
+        const not = queryString.includes("not all");
+        const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+        const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+        let res = Boolean(minWidth || maxWidth);
+        if (minWidth && res) res = ssrWidth >= pxValue(minWidth[1]);
+        if (maxWidth && res) res = ssrWidth <= pxValue(maxWidth[1]);
+        return not ? !res : res;
+      });
+      return;
+    }
+    if (!isSupported.value) return;
+    mediaQuery.value = window$1.matchMedia(toValue(query));
+    matches.value = mediaQuery.value.matches;
+  });
+  useEventListener(mediaQuery, "change", handler, { passive: true });
+  return computed(() => matches.value);
+}
+// @__NO_SIDE_EFFECTS__
+function useBreakpoints(breakpoints, options = {}) {
+  function getValue$1(k, delta) {
+    let v = toValue(breakpoints[toValue(k)]);
+    if (delta != null) v = increaseWithUnit(v, delta);
+    if (typeof v === "number") v = `${v}px`;
+    return v;
+  }
+  const { window: window$1 = defaultWindow, strategy = "min-width", ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
+  const ssrSupport = typeof ssrWidth === "number";
+  const mounted = ssrSupport ? shallowRef(false) : { value: true };
+  if (ssrSupport) tryOnMounted(() => mounted.value = !!window$1);
+  function match(query, size) {
+    if (!mounted.value && ssrSupport) return query === "min" ? ssrWidth >= pxValue(size) : ssrWidth <= pxValue(size);
+    if (!window$1) return false;
+    return window$1.matchMedia(`(${query}-width: ${size})`).matches;
+  }
+  const greaterOrEqual = (k) => {
+    return useMediaQuery(() => `(min-width: ${getValue$1(k)})`, options);
+  };
+  const smallerOrEqual = (k) => {
+    return useMediaQuery(() => `(max-width: ${getValue$1(k)})`, options);
+  };
+  const shortcutMethods = Object.keys(breakpoints).reduce((shortcuts, k) => {
+    Object.defineProperty(shortcuts, k, {
+      get: () => strategy === "min-width" ? greaterOrEqual(k) : smallerOrEqual(k),
+      enumerable: true,
+      configurable: true
+    });
+    return shortcuts;
+  }, {});
+  function current() {
+    const points = Object.keys(breakpoints).map((k) => [
+      k,
+      shortcutMethods[k],
+      pxValue(getValue$1(k))
+    ]).sort((a, b) => a[2] - b[2]);
+    return computed(() => points.filter(([, v]) => v.value).map(([k]) => k));
+  }
+  return Object.assign(shortcutMethods, {
+    greaterOrEqual,
+    smallerOrEqual,
+    greater(k) {
+      return useMediaQuery(() => `(min-width: ${getValue$1(k, 0.1)})`, options);
+    },
+    smaller(k) {
+      return useMediaQuery(() => `(max-width: ${getValue$1(k, -0.1)})`, options);
+    },
+    between(a, b) {
+      return useMediaQuery(() => `(min-width: ${getValue$1(a)}) and (max-width: ${getValue$1(b, -0.1)})`, options);
+    },
+    isGreater(k) {
+      return match("min", getValue$1(k, 0.1));
+    },
+    isGreaterOrEqual(k) {
+      return match("min", getValue$1(k));
+    },
+    isSmaller(k) {
+      return match("max", getValue$1(k, -0.1));
+    },
+    isSmallerOrEqual(k) {
+      return match("max", getValue$1(k));
+    },
+    isInBetween(a, b) {
+      return match("min", getValue$1(a)) && match("max", getValue$1(b, -0.1));
+    },
+    current,
+    active() {
+      const bps = current();
+      return computed(() => bps.value.length === 0 ? "" : bps.value.at(strategy === "min-width" ? -1 : 0));
+    }
+  });
+}
+export {
+  _sfc_main as _,
+  onClickOutside as o,
+  useBreakpoints as u
+};
+//# sourceMappingURL=index-CJwlO351.js.map