@pantograph/vue 0.25.4 → 0.25.6

package/dist/Select.vue_vue_type_style_index_0_lang-DzWX4QRp.js

@@ -0,0 +1,770 @@
+import { defineComponent as te, createElementBlock as ze, openBlock as _e, normalizeClass as ke, unref as le, renderSlot as Be, computed as C, h as a, ref as ve, watch as we, useSlots as De, useAttrs as Ae, createBlock as Fe, normalizeProps as Ce, guardReactiveProps as ye, withCtx as Se, createVNode as We, createSlots as $e, renderList as Ee } from "vue";
+import { createContext as Pe, SelectItem as Ge, SelectItemIndicator as Ne, SelectTrigger as Re, Primitive as je, injectSelectRootContext as Ke, SelectPortal as Me, SelectContent as qe, useEmitAsProps as Ue, SelectRoot as He } from "reka-ui";
+import { isString as ee, cloneDeep as he, omit as be, isFunction as Ve, omitBy as Je, pick as Oe, isUndefined as Qe } from "es-toolkit";
+import { g as Te, a as ge } from "./options-Bh1s18jm.js";
+import { k as p, e as ce, l as q, s as Y, m as Z, h as Xe, j as Ye, g as Ze, t as Le, o as et } from "./Icon.vue_vue_type_style_index_0_lang-DkeXz23k.js";
+import { getBemBlock as tt, getBemElement as y, generateVariantClassList as E, normCls as _ } from "@pantograph/utils";
+import { cva as de } from "class-variance-authority";
+import { _ as ot } from "./Empty.vue_vue_type_style_index_0_lang-C1kPtilP.js";
+import { _ as nt } from "./Skeleton.vue_vue_type_style_index_0_lang-2rpO7HY2.js";
+import { _ as xe } from "./Divider.vue_vue_type_style_index_0_lang-CfBklijs.js";
+import { u as rt } from "./useInputDataStates-BNwXgt9l.js";
+import { u as it } from "./useLazyLoading-Zo-PEp2E.js";
+import { g as at, b as lt } from "./Popover.vue_vue_type_style_index_0_lang-BolWR0Oq.js";
+import { u as pt } from "./ConfigProvider.vue_vue_type_script_setup_true_lang-D8R0hBKt.js";
+import { _ as st } from "./ScrollContainer.vue_vue_type_style_index_0_lang-Dl1jP8xY.js";
+import { _ as ut } from "./Chip.vue_vue_type_style_index_0_lang-DZpyBQK1.js";
+import { _ as ct } from "./ChipGroup.vue_vue_type_style_index_0_lang-CeTQpuIw.js";
+const me = ["sm", "md", "lg"], gt = ["error", "warning", "success"], [Ie, dt] = Pe("Select"), [mt, ft] = Pe("_Select"), k = tt("select"), vt = /* @__PURE__ */ te({
+  ...Te("SelectLabel"),
+  __name: "SelectLabel",
+  setup(m) {
+    return (e, o) => (_e(), ze("div", {
+      class: ke(le(y)(le(k), "label"))
+    }, [
+      Be(e.$slots, "default")
+    ], 2));
+  }
+}), ue = te({
+  name: ge("SelectOption"),
+  props: {
+    option: {
+      type: [Object, String],
+      required: !0
+    }
+  },
+  slots: Object,
+  setup(m, { slots: e }) {
+    const o = Ie(), t = C(() => {
+      switch (o.getSize.value) {
+        case "sm":
+          return "2xsm";
+        case "lg":
+          return "sm";
+        case "md":
+        default:
+          return "xsm";
+      }
+    }), w = C(() => o.getOptionValue(m.option)), u = C(() => o.getOptionLabel(m.option)), G = C(() => o.getOptionIcon(m.option)), K = C(() => o.getOptionDisabled(m.option)), I = y(k, "option"), U = de(I, {
+      variants: {
+        size: E(me, I)
+      }
+    });
+    if (!m.option) throw new Error("option is required");
+    const D = () => {
+      var h;
+      const V = (h = e.indicator) == null ? void 0 : h.call(e, { option: m.option });
+      return p(V) ? a(
+        Ne,
+        { asChild: !0 },
+        () => a(ce, { icon: o.props.indicatorIcon, size: t.value })
+      ) : V;
+    }, A = () => {
+      var P, F, M;
+      const V = (P = e.default) == null ? void 0 : P.call(e, { option: m.option }), h = [];
+      if (!p(V)) h.push(V);
+      else {
+        const W = (F = e.leading) == null ? void 0 : F.call(e, { option: m.option }), H = !p(W);
+        if (G.value || H) {
+          let L;
+          H ? L = W : L = a(ce, { icon: G.value, size: t.value }), h.push(
+            a(
+              "div",
+              { class: _(y(I, "leading"), o.props.itemLeadingCls) },
+              L
+            )
+          );
+        }
+        let l;
+        const O = (M = e.text) == null ? void 0 : M.call(e, { option: m.option });
+        p(O) ? l = u.value : l = O, h.push(
+          a(
+            "div",
+            {
+              class: _(y(I, "text"), o.props.optionTextCls)
+            },
+            l
+          )
+        );
+      }
+      return a(
+        "div",
+        { class: _(y(I, "content"), o.props.optionContentCls) },
+        h
+      );
+    };
+    return () => a(
+      Ge,
+      {
+        value: w.value,
+        textValue: u.value,
+        disabled: K.value,
+        class: _(
+          U({
+            size: o.getSize.value
+          }),
+          o.props.optionCls
+        )
+      },
+      () => [A(), D()]
+    );
+  }
+}), Ct = te({
+  name: ge("SelectTrigger"),
+  props: {
+    getOptionSlot: {
+      type: Function,
+      required: !0
+    }
+  },
+  setup(m, { slots: e, attrs: o }) {
+    const t = Ie(), w = ({ value: l }, O) => {
+      if (O.stopPropagation(), l && Y(t.modelValue.value) && !t.getDisabled.value) {
+        const L = t.modelValue.value.filter((J) => J !== l);
+        t.modelValue.value = L, t.emit("update:modelValue", L);
+      }
+    }, u = y(k, "trigger"), G = de(u, {
+      variants: {
+        size: E(me, u),
+        status: E(gt, u),
+        bordered: E("bordered", u),
+        multiple: E("multiple", u),
+        contentFit: E("content-fit", u),
+        wrapped: E("wrapped", u),
+        filled: E("filled", u)
+      }
+    }), K = C(() => {
+      switch (t.getSize.value) {
+        case "sm":
+          return "xsm";
+        case "lg":
+          return "md";
+        case "md":
+        default:
+          return "sm";
+      }
+    }), I = C(() => {
+      switch (t.getSize.value) {
+        case "sm":
+          return "2xsm";
+        case "md":
+        default:
+          return "xsm";
+      }
+    }), U = C(() => {
+      if (!t.props.multiple && ee(t.modelValue.value) && !q(t.modelValue.value))
+        return t.getOptionByValue(t.modelValue.value);
+    }), D = (l = U.value) => {
+      if (t.props.selectedItemIconAsTrailingIcon && Z(l) && "icon" in l)
+        return l.icon;
+    }, A = C(() => D()), V = C(() => {
+      if (!t.props.noTrailing)
+        return t.props.trailingIcon;
+    }), h = C(
+      () => !q(t.modelValue.value) && t.props.multiple && Y(t.modelValue.value)
+    ), P = C(() => ({
+      modelValue: he(t.modelValue.value),
+      open: he(t.open.value)
+    })), F = (l) => ({
+      ...P.value,
+      option: t.getOptionByValue(l)
+    }), M = C(() => ({
+      disabled: t.getDisabled.value,
+      reference: t.props.reference,
+      tabindex: t.getDisabled.value ? void 0 : 0,
+      as: "div",
+      class: _(
+        G({
+          size: t.getSize.value,
+          status: t.getStatus.value === "success" && q(t.modelValue.value) ? void 0 : t.getStatus.value,
+          bordered: t.props.bordered,
+          multiple: t.props.multiple,
+          contentFit: t.props.contentFit,
+          wrapped: t.props.wrapped,
+          filled: !q(t.modelValue.value)
+        }),
+        t.props.triggerCls
+      ),
+      ...o
+    })), W = (l, O = I.value) => a(ce, { icon: l, size: O }), H = () => {
+      var L;
+      let l;
+      const O = (L = e.triggerTrailing) == null ? void 0 : L.call(e, P.value);
+      if (p(O) ? V.value && (l = W(V.value)) : l = O, l)
+        return a(
+          "div",
+          { class: _(y(u, "trailing"), t.props.triggerTrailingCls) },
+          l
+        );
+    };
+    return () => {
+      var J;
+      const l = (J = e.trigger) == null ? void 0 : J.call(e, P.value), L = (() => {
+        if (p(l)) return !1;
+        const T = Xe(l) ?? null, N = T.length === 1 ? T[0] : T;
+        return N ? Ye(N) && !Ze(N) : !0;
+      })();
+      return a(
+        Re,
+        { ...M.value, asChild: L, key: String(L) },
+        {
+          default: () => {
+            var Q;
+            if (!p(l))
+              return l;
+            const T = (Q = e.triggerLeading) == null ? void 0 : Q.call(e, P.value), N = !p(T), oe = () => {
+              var $;
+              if (!t.props.multiple && !Y(t.modelValue.value)) {
+                const j = ($ = m.getOptionSlot(
+                  "leading",
+                  t.modelValue.value
+                )) == null ? void 0 : $();
+                if (N || j || A.value || t.props.leadingIcon) {
+                  let r;
+                  return p(j) ? A.value ? r = W(A.value) : N ? r = T : t.props.leadingIcon && (r = W(t.props.leadingIcon)) : r = j, a(
+                    "div",
+                    {
+                      class: _(
+                        y(u, "leading"),
+                        t.props.triggerLeadingCls
+                      )
+                    },
+                    r
+                  );
+                }
+              }
+            }, pe = () => {
+              const $ = [];
+              if (q(t.modelValue.value)) {
+                if (t.props.placeholder && !t.props.multiple) {
+                  const j = () => {
+                    var b;
+                    const r = (b = e.placeholder) == null ? void 0 : b.call(e, P.value);
+                    return p(r) ? t.props.placeholder : r;
+                  };
+                  $.push(j());
+                }
+              } else {
+                const r = (() => {
+                  var B, f, g;
+                  const b = (B = e.triggerValue) == null ? void 0 : B.call(e, P.value);
+                  if (!p(b)) return b;
+                  if (t.props.multiple && Y(t.modelValue.value))
+                    return a(
+                      ct,
+                      {
+                        maxCount: t.props.maxCount,
+                        size: K.value,
+                        color: "primary",
+                        closeable: !t.getDisabled.value,
+                        noPopover: !0,
+                        noWrap: !t.props.wrapped,
+                        class: _(y(u, "tag_list"), t.props.tagListCls),
+                        onClose: w
+                      },
+                      () => t.modelValue.value.map((c) => {
+                        var X;
+                        const x = (n) => {
+                          var v;
+                          const i = (v = e.tagClose) == null ? void 0 : v.call(e, {
+                            ...F(c),
+                            onClose: n
+                          });
+                          return p(i) ? null : i;
+                        }, z = (X = m.getOptionSlot("default", c)) == null ? void 0 : X(), se = () => {
+                          var v, s;
+                          const n = (v = m.getOptionSlot("text", c)) == null ? void 0 : v(), i = (s = e.tagText) == null ? void 0 : s.call(e, F(c));
+                          return p(i) ? p(z) ? p(n) ? t.getLabelByValue(c) : n : z : i;
+                        }, ie = ({ size: n }) => {
+                          var S, d;
+                          if (!p(z)) return null;
+                          const i = (S = m.getOptionSlot("leading", c)) == null ? void 0 : S(), v = (d = e.tagLeading) == null ? void 0 : d.call(e, F(c)), s = D(t.getOptionByValue(c)) ?? t.props.leadingIcon;
+                          return p(v) ? p(i) ? s ? W(s, n) : p(T) ? null : T : i : v;
+                        }, ae = () => {
+                          var i;
+                          const n = (i = e.tagTrailing) == null ? void 0 : i.call(e, F(c));
+                          return p(n) ? null : n;
+                        };
+                        return a(
+                          ut,
+                          {
+                            value: c,
+                            class: _(y(u, "tag"), t.props.tagCls),
+                            closeIconCls: y(u, "tag__close")
+                          },
+                          {
+                            text: se,
+                            leading: ie,
+                            trailing: ae,
+                            close: x
+                          }
+                        );
+                      })
+                    );
+                  if (!Y(t.modelValue.value)) {
+                    const c = (f = m.getOptionSlot("default", t.modelValue.value)) == null ? void 0 : f(), x = (g = m.getOptionSlot("text", t.modelValue.value)) == null ? void 0 : g();
+                    return p(c) ? p(x) ? ee(t.modelValue.value) ? t.getLabelByValue(t.modelValue.value) : t.modelValue.value : x : c;
+                  }
+                })();
+                r && $.push(r);
+              }
+              return $;
+            }, R = [], ne = oe();
+            p(ne) || R.push(ne), R.push(
+              a(
+                je,
+                {
+                  class: _(
+                    y(u, "content"),
+                    t.props.triggerContentCls,
+                    q(t.modelValue.value) ? t.props.triggerContentPlaceholderCls : t.props.triggerContentValueCls
+                  ),
+                  as: "div",
+                  key: String(h.value),
+                  asChild: h.value
+                },
+                { default: pe }
+              )
+            );
+            const re = H();
+            return p(re) || R.push(re), R;
+          }
+        }
+      );
+    };
+  }
+}), yt = te({
+  name: ge("SelectWrapper"),
+  setup(m, { slots: e }) {
+    const o = mt(), t = Ke(), w = ve();
+    it({ target: w });
+    const u = ve(), G = at({ triggerRef: u, props: o.props }), { getFlipOnDir: K, getDir: I } = pt(), U = K("reversePlacementOnDir"), D = I(), A = lt({
+      props: o.props,
+      flip: U,
+      emitsAsProps: o.emitsAsProps,
+      _dir: D,
+      controlAutoFocus: !1,
+      extraPropNames: ["bodyLock", "position"]
+    }), V = ({
+      key: r,
+      getterKey: b,
+      defaultValue: B,
+      noReturnOption: f
+    }) => (g) => {
+      const c = Ve(B) ? B(g) : B;
+      if (Z(g)) {
+        const x = g[r] ?? c, z = b && o.props[b];
+        if (z) {
+          if (ee(z))
+            return g[z] ?? x;
+          if (Ve(z)) return z(g) ?? x;
+        }
+        return x;
+      }
+      return ee(g) && !f ? g ?? c : c;
+    }, h = V({
+      getterKey: "getValue",
+      key: "value"
+    }), P = V({
+      getterKey: "getLabel",
+      key: "label",
+      defaultValue: h
+    }), F = V({
+      getterKey: "getIcon",
+      key: "icon",
+      noReturnOption: !0
+    }), M = (r) => {
+      var b;
+      if ((b = o.props.options) != null && b.length)
+        for (const B of o.props.options) {
+          if (h(B) === r) return B;
+          const f = O(B);
+          if (f != null && f.length) {
+            for (const g of f)
+              if (h(g) === r) return g;
+          }
+        }
+      return r;
+    }, W = (r) => {
+      const b = M(r);
+      return b ? P(b) ?? r : r;
+    }, H = V({
+      getterKey: "getDisabled",
+      key: "disabled",
+      defaultValue: !1,
+      noReturnOption: !0
+    }), l = V({
+      getterKey: "getGroupLabel",
+      key: "label",
+      noReturnOption: !0
+    }), O = V({
+      getterKey: "getGroupOptions",
+      key: "options",
+      noReturnOption: !0
+    }), { getDisabled: L, getStatus: J, getSize: T } = rt({
+      getDisabled: () => o.props.disabled,
+      getSize: () => o.props.size,
+      getStatus: () => o.props.status
+    });
+    dt({
+      props: o.props,
+      attrs: o.attrs,
+      emit: o.emit,
+      getOptionValue: h,
+      getOptionLabel: P,
+      getOptionDisabled: H,
+      getOptionIcon: F,
+      getOptionByValue: M,
+      getLabelByValue: W,
+      getDisabled: L,
+      getStatus: J,
+      getSize: T,
+      ...t,
+      modelValue: t.modelValue
+    }), we(
+      () => [o.props.clearOnChangeMultiple, o.props.multiple],
+      () => {
+        o.props.clearOnChangeMultiple && (t.modelValue.value = void 0, o.emit("update:modelValue", void 0));
+      }
+    );
+    const N = C(() => {
+      const r = o.props.scrollContainerProps ?? {};
+      return {
+        ...r,
+        areaCls: [
+          y(k, "scroll_area"),
+          r == null ? void 0 : r.class,
+          r == null ? void 0 : r.areaCls
+        ]
+      };
+    }), oe = y(k, "popup"), pe = de(oe, {
+      variants: {
+        size: E(me, oe)
+      }
+    }), R = (r) => {
+      if (et(r))
+        return `${r}px`;
+      if (typeof r == "string")
+        return r;
+    }, ne = C(() => R(o.props.popupWidth)), re = C(() => R(o.props.popupHeight)), Q = C(() => R(o.props.minWidth)), $ = C(() => ({
+      type: T.value === "sm" ? "simple" : "advance",
+      ...be(o.props.emptyProps ?? {}, ["class"])
+    })), j = C(() => be(o.props.skeletonProps ?? {}, ["class"]));
+    return () => {
+      var ie, ae, X;
+      const r = (n) => {
+        var i;
+        if ((i = o.props.options) != null && i.length && n > 0)
+          return !!o.props.options[n - 1];
+      }, b = (n) => {
+        var i, v;
+        if ((i = o.props.options) != null && i.length && n > 0) {
+          const s = o.props.options[n - 1];
+          return !!(s && ((v = O(s)) != null && v.length));
+        }
+      }, B = (ie = e.default) == null ? void 0 : ie.call(e, {}), f = (ae = Le(B, ue)) == null ? void 0 : ae.filter(
+        (n) => {
+          var i;
+          return Z(n == null ? void 0 : n.props) && ((i = n == null ? void 0 : n.props) == null ? void 0 : i.option);
+        }
+      ), g = [];
+      (o.props.options ?? []).forEach((n, i) => {
+        const v = (S) => a(
+          ue,
+          {
+            option: S
+          },
+          {
+            default: () => {
+              var d;
+              return (d = e.option) == null ? void 0 : d.call(e, { option: S });
+            },
+            leading: () => {
+              var d;
+              return (d = e.optionLeading) == null ? void 0 : d.call(e, { option: S });
+            },
+            indicator: () => {
+              var d;
+              return (d = e.optionIndicator) == null ? void 0 : d.call(e, { option: S });
+            },
+            text: () => {
+              var d;
+              return (d = e.optionText) == null ? void 0 : d.call(e, { option: S });
+            }
+          }
+        ), s = O(n);
+        if (s != null && s.length) {
+          r(i) && g.push(a(xe));
+          const S = l(n);
+          S && g.push(
+            a(vt, { class: o.props.labelCls }, () => S)
+          ), s.forEach((d) => {
+            g.push(v(d));
+          });
+        } else b(i) ? g.push(a(xe)) : g.push(v(n));
+      });
+      const c = Le(g, ue).filter(
+        (n) => {
+          var i;
+          return Z(n == null ? void 0 : n.props) && ((i = n == null ? void 0 : n.props) == null ? void 0 : i.option);
+        }
+      ), x = !!(c != null && c.length || f != null && f.length), z = (n, i) => {
+        var v;
+        if (x && !q(i) && ee(i)) {
+          const s = f != null && f.length ? f : c;
+          if (s.length) {
+            const S = s.find(
+              (d) => {
+                var fe;
+                return Z(d.props) && h((fe = d.props) == null ? void 0 : fe.option) === i;
+              }
+            );
+            return (v = S == null ? void 0 : S.children) == null ? void 0 : v[n];
+          }
+        }
+      }, se = () => {
+        var i, v;
+        const n = [];
+        if (x || o.props.loading) {
+          const s = [];
+          if (x && (f != null && f.length ? s.push(B) : s.push(...g)), o.props.loading) {
+            const S = (i = e.loading) == null ? void 0 : i.call(e, {});
+            if (!p(S)) s.push(S);
+            else {
+              const d = new Array(x ? 2 : o.props.loadingRowCount).fill(1);
+              s.push(
+                ...d.map(
+                  () => a(nt, {
+                    size: T.value,
+                    class: _(
+                      y(k, "skeleton"),
+                      o.props.skeletonCls
+                    ),
+                    ...j.value
+                  })
+                )
+              );
+            }
+          }
+          n.push(
+            a(
+              "div",
+              {
+                class: _(y(k, "options"), o.props.optionsCls)
+              },
+              s
+            )
+          );
+        } else if (!x) {
+          const s = (v = e.empty) == null ? void 0 : v.call(e, $.value);
+          p(s) ? n.push(
+            a(
+              ot,
+              {
+                class: _(y(k, "empty"), o.props.emptyCls),
+                ...$.value
+              },
+              {
+                title: e.emptyTitle,
+                description: e.emptyDescription,
+                actions: e.emptyActions,
+                image: e.emptyImage
+              }
+            )
+          ) : n.push(s);
+        }
+        return o.props.lazyLoading && n.push(
+          a(
+            "div",
+            { class: y(k, "lazy_loading") },
+            a("div", { class: y(k, "lazy_loading_trigger"), ref: w })
+          )
+        ), n;
+      };
+      return [
+        a(
+          Ct,
+          {
+            getOptionSlot: z,
+            ref: u,
+            ...o.attrs,
+            style: {
+              ...((X = o.attrs) == null ? void 0 : X.style) ?? {},
+              "--ptc-select-trigger-min-w": Q.value
+            }
+          },
+          {
+            trigger: e.trigger,
+            triggerLeading: e.triggerLeading,
+            placeholder: e.placeholder,
+            triggerValue: e.triggerValue,
+            triggerTrailing: e.triggerTrailing,
+            tagClose: e.tagClose,
+            tagTrailing: e.tagTrailing,
+            tagLeading: e.tagLeading,
+            tagText: e.tagText
+          }
+        ),
+        a(
+          Me,
+          G.value,
+          () => a(
+            qe,
+            {
+              ...A.value,
+              class: _(pe(o.props), o.props.popupCls),
+              style: {
+                display: t.open.value ? void 0 : "none",
+                zIndex: o.props.zIndex,
+                "--ptc-select-popup-width": o.props.samePopupWidth ? void 0 : ne.value,
+                "--ptc-select-popup-height": re.value,
+                "--ptc-select-trigger-min-w": Q.value
+              }
+            },
+            () => a(st, N.value, se)
+          )
+        )
+      ];
+    };
+  }
+}), Ft = /* @__PURE__ */ te({
+  ...Te("Select"),
+  __name: "Select",
+  props: {
+    status: {},
+    size: { default: "md" },
+    multiple: { type: Boolean, default: void 0 },
+    contentFit: { type: Boolean },
+    wrapped: { type: Boolean },
+    noTrailing: { type: Boolean },
+    leadingIcon: {},
+    zIndex: {},
+    trailingIcon: { default: "tabler:chevron-down" },
+    selectedItemIconAsTrailingIcon: { type: Boolean, default: !0 },
+    maxCount: {},
+    to: {},
+    placeholder: {},
+    indicatorIcon: { default: "tabler:check" },
+    options: {},
+    getDisabled: {},
+    getLabel: {},
+    getValue: {},
+    getGroupOptions: {},
+    getGroupLabel: {},
+    getIcon: {},
+    placement: { default: "bottom" },
+    reversePlacementOnDir: {},
+    loading: { type: Boolean },
+    skeletonProps: {},
+    loadingRowCount: { default: 10 },
+    lazyLoading: { type: Boolean },
+    bordered: { type: Boolean, default: !0 },
+    clearOnChangeMultiple: { type: Boolean, default: !0 },
+    triggerCls: {},
+    triggerLeadingCls: {},
+    triggerContentCls: {},
+    triggerContentPlaceholderCls: {},
+    triggerContentValueCls: {},
+    triggerTrailingCls: {},
+    itemLeadingCls: {},
+    optionCls: {},
+    tagListCls: {},
+    tagCls: {},
+    popupCls: {},
+    labelCls: {},
+    optionsCls: {},
+    optionTextCls: {},
+    optionContentCls: {},
+    emptyCls: {},
+    skeletonCls: {},
+    scrollContainerProps: {},
+    emptyProps: {},
+    samePopupWidth: { type: Boolean, default: !0 },
+    popupHeight: { default: 384 },
+    popupWidth: {},
+    minWidth: {},
+    open: { type: Boolean, default: void 0 },
+    defaultOpen: { type: Boolean, default: void 0 },
+    defaultValue: {},
+    modelValue: {},
+    by: {},
+    dir: {},
+    autocomplete: {},
+    disabled: { type: Boolean, default: void 0 },
+    name: {},
+    required: { type: Boolean },
+    reference: {},
+    forceMount: { type: Boolean, default: void 0 },
+    position: { default: "popper" },
+    bodyLock: { type: Boolean },
+    side: {},
+    sideOffset: { default: 4 },
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean, default: void 0 },
+    collisionBoundary: {},
+    collisionPadding: { default: 4 },
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean, default: void 0 },
+    positionStrategy: { default: "fixed" },
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean, default: void 0 },
+    prioritizePosition: { type: Boolean, default: void 0 },
+    asChild: { type: Boolean },
+    as: {},
+    defer: { type: Boolean }
+  },
+  emits: ["update:modelValue", "update:open", "closeAutoFocus", "escapeKeyDown", "pointerDownOutside"],
+  setup(m, { emit: e }) {
+    const o = m, t = e, w = Ue(t), u = C(
+      () => Je(
+        {
+          ...Oe(o, [
+            "open",
+            "defaultOpen",
+            "defaultValue",
+            "modelValue",
+            "by",
+            "dir",
+            "multiple",
+            "autocomplete",
+            "disabled"
+          ]),
+          ...Oe(w, [
+            "onUpdate:modelValue",
+            "onUpdate:open"
+          ])
+        },
+        Qe
+      )
+    ), G = De(), K = Ae();
+    return ft({
+      attrs: K,
+      props: o,
+      emit: t,
+      emitsAsProps: w
+    }), (I, U) => (_e(), Fe(le(He), Ce(ye(u.value)), {
+      default: Se(() => [
+        We(le(yt), null, $e({ _: 2 }, [
+          Ee(Object.keys(G), (D) => ({
+            name: D,
+            fn: Se((A) => [
+              Be(I.$slots, D, Ce(ye(A)))
+            ])
+          }))
+        ]), 1024)
+      ]),
+      _: 3
+    }, 16));
+  }
+});
+export {
+  ue as S,
+  Ft as _,
+  vt as a,
+  me as b,
+  gt as c,
+  Ie as i,
+  dt as p
+};