@youcan/celeste 0.6.29 → 0.6.30

package/dist/es/alert.js

@@ -0,0 +1,112 @@
+import { defineComponent, openBlock, createElementBlock, unref, normalizeClass, createElementVNode, renderSlot, createCommentVNode, withModifiers } from "vue";
+import { uid } from "./crypto.js";
+import { c as clsx } from "./chunks/clsx.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _hoisted_1 = ["aria-labelledby", "aria-describedby", "role"];
+const _hoisted_2 = {
+  class: "celeste-alert-inner",
+  role: "presentation"
+};
+const _hoisted_3 = {
+  role: "presentation",
+  class: "celeste-alert-content"
+};
+const _hoisted_4 = ["id"];
+const _hoisted_5 = ["id"];
+const _hoisted_6 = {
+  key: 0,
+  class: "celeste-alert-actions",
+  role: "presentation"
+};
+const _hoisted_7 = {
+  key: 0,
+  class: "celeste-alert-action-primary"
+};
+const _hoisted_8 = {
+  key: 1,
+  class: "celeste-alert-action-divider"
+};
+const _hoisted_9 = {
+  key: 2,
+  class: "celeste-alert-action-secondary"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "alert",
+  props: {
+    class: {},
+    size: { default: "xs" },
+    variant: { default: "fill" },
+    state: { default: "information" },
+    dismissable: { type: Boolean, default: false }
+  },
+  emits: ["dismiss"],
+  setup(__props) {
+    const props = __props;
+    const labelledby = uid();
+    const describedby = uid();
+    const ICON_MAP = {
+      warning: "i-celeste-alert-fill",
+      feature: "i-celeste-magic-fill",
+      error: "i-celeste-error-warning-fill",
+      success: "i-celeste-checkbox-circle-fill",
+      information: "i-celeste-information-fill"
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        "aria-labelledby": unref(labelledby),
+        "aria-describedby": unref(describedby),
+        role: _ctx.$slots.primary || _ctx.$slots.secondary ? "alert-dialog" : "alert",
+        class: normalizeClass(["celeste-alert", unref(clsx)(
+          `celeste-alert--${_ctx.size}`,
+          `celeste-alert--${_ctx.variant}--${_ctx.state}`,
+          props.class
+        )])
+      }, [
+        createElementVNode("i", {
+          class: normalizeClass(["celeste-alert-icon", [`celeste-alert-icon--${_ctx.variant}--${_ctx.state}`, ICON_MAP[props.state]]])
+        }, null, 2),
+        createElementVNode("div", _hoisted_2, [
+          createElementVNode("div", _hoisted_3, [
+            renderSlot(_ctx.$slots, "default", {}, () => [
+              createElementVNode("h5", {
+                id: unref(labelledby),
+                class: "celeste-alert-title"
+              }, [
+                renderSlot(_ctx.$slots, "title", {}, void 0, true)
+              ], 8, _hoisted_4),
+              _ctx.size === "lg" && _ctx.$slots.description ? (openBlock(), createElementBlock("div", {
+                key: 0,
+                id: unref(describedby),
+                class: "celeste-alert-description"
+              }, [
+                renderSlot(_ctx.$slots, "description", {}, void 0, true)
+              ], 8, _hoisted_5)) : createCommentVNode("", true)
+            ], true)
+          ]),
+          _ctx.$slots.primary || _ctx.$slots.secondary ? (openBlock(), createElementBlock("div", _hoisted_6, [
+            _ctx.$slots.primary ? (openBlock(), createElementBlock("div", _hoisted_7, [
+              renderSlot(_ctx.$slots, "primary", {}, void 0, true)
+            ])) : createCommentVNode("", true),
+            _ctx.$slots.primary && _ctx.$slots.secondary && _ctx.size === "lg" ? (openBlock(), createElementBlock("div", _hoisted_8, " ∙ ")) : createCommentVNode("", true),
+            _ctx.$slots.secondary && _ctx.size === "lg" ? (openBlock(), createElementBlock("div", _hoisted_9, [
+              renderSlot(_ctx.$slots, "secondary", {}, void 0, true)
+            ])) : createCommentVNode("", true)
+          ])) : createCommentVNode("", true)
+        ]),
+        _ctx.dismissable ? (openBlock(), createElementBlock("a", {
+          key: 0,
+          href: "#",
+          "aria-label": "close",
+          class: normalizeClass(["celeste-alert-close", [`celeste-alert-close--${_ctx.variant}`]]),
+          onClick: _cache[0] || (_cache[0] = withModifiers(($event) => _ctx.$emit("dismiss"), ["prevent"]))
+        }, _cache[1] || (_cache[1] = [
+          createElementVNode("i", { class: "i-celeste-close-line" }, null, -1)
+        ]), 2)) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+const alert = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-a07f0877"]]);
+export {
+  alert as default
+};

package/dist/es/alpha-slider.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "./chunks/alpha-slider.js";
+export {
+  _sfc_main as default
+};

package/dist/es/badge.js

@@ -0,0 +1,56 @@
+import { defineComponent, openBlock, createElementBlock, normalizeClass, unref, createCommentVNode, toDisplayString } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _hoisted_1 = ["aria-label", "aria-disabled"];
+const _hoisted_2 = {
+  key: 0,
+  class: "dot i-celeste-dot"
+};
+const _hoisted_3 = { key: 2 };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "badge",
+  props: {
+    size: { default: "md" },
+    variant: { default: "fill" },
+    type: { default: "basic" },
+    state: {},
+    disabled: { type: Boolean },
+    icon: {},
+    label: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass(unref(clsx)(
+          "celeste-badge",
+          `celeste-badge-${_ctx.size}`,
+          `celeste-badge-${_ctx.type}`,
+          `celeste-badge-${_ctx.state}`,
+          `celeste-badge-${_ctx.variant}`,
+          _ctx.disabled && "celeste-badge-disabled",
+          props.class
+        )),
+        "aria-label": _ctx.label,
+        "aria-disabled": _ctx.disabled || void 0,
+        role: "badge"
+      }, [
+        _ctx.type === "dot" ? (openBlock(), createElementBlock("i", _hoisted_2)) : createCommentVNode("", true),
+        _ctx.type === "leading-icon" ? (openBlock(), createElementBlock("i", {
+          key: 1,
+          class: normalizeClass(_ctx.icon)
+        }, null, 2)) : createCommentVNode("", true),
+        _ctx.label ? (openBlock(), createElementBlock("span", _hoisted_3, toDisplayString(_ctx.label), 1)) : createCommentVNode("", true),
+        _ctx.type === "trailing-icon" ? (openBlock(), createElementBlock("i", {
+          key: 3,
+          class: normalizeClass(_ctx.icon)
+        }, null, 2)) : createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+const Badge = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-f6cc59c9"]]);
+export {
+  Badge as default
+};

package/dist/es/button.js

@@ -0,0 +1,40 @@
+import { defineComponent, openBlock, createBlock, unref, normalizeClass, withCtx, renderSlot } from "vue";
+import { c as clsx } from "./chunks/clsx.js";
+import { f as O } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "button",
+  props: {
+    class: {},
+    size: { default: "md" },
+    intent: { default: "primary" },
+    variant: { default: "fill" },
+    asChild: { type: Boolean },
+    as: { default: "button" }
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(O), {
+        as: _ctx.as,
+        "as-child": _ctx.asChild,
+        class: normalizeClass(unref(clsx)(
+          "celeste-button",
+          `celeste-button-intent-${_ctx.intent}`,
+          `celeste-button-size-${_ctx.size}`,
+          `celeste-button-variant-${_ctx.variant}`,
+          props.class
+        ))
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 8, ["as", "as-child", "class"]);
+    };
+  }
+});
+const Button = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-ba4c26eb"]]);
+export {
+  Button as default
+};

package/dist/es/checkbox-label.js

@@ -0,0 +1,113 @@
+import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, createVNode, renderSlot, createElementVNode, createCommentVNode } from "vue";
+import { useDelegatedProps } from "./use-delegated-props.js";
+import { c as clsx } from "./chunks/clsx.js";
+import { B as Oh, f as O } from "./chunks/index.js";
+import { _ as _export_sfc } from "./chunks/_plugin-vue_export-helper.js";
+const _hoisted_1 = { role: "presentation" };
+const _hoisted_2 = {
+  role: "presentation",
+  class: "celeste-checkbox-label-row"
+};
+const _hoisted_3 = {
+  role: "presentation",
+  class: "celeste-checkbox-label-content"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "checkbox-label",
+  props: {
+    for: {},
+    asChild: { type: Boolean },
+    as: {},
+    sublabel: {},
+    information: {},
+    required: { type: Boolean },
+    description: {},
+    disabled: { type: Boolean },
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Oh), mergeProps(unref(delegatedProps), {
+        "aria-required": _ctx.required,
+        "aria-disabcled": _ctx.disabled,
+        class: unref(clsx)("celeste-checkbox-label", props.class)
+      }), {
+        default: withCtx(() => [
+          createVNode(unref(O), {
+            "as-child": "",
+            class: "celeste-checkbox-label-checkbox"
+          }, {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default", {}, void 0, true)
+            ]),
+            _: 3
+          }),
+          createElementVNode("div", _hoisted_1, [
+            createElementVNode("div", _hoisted_2, [
+              createElementVNode("div", null, [
+                createVNode(unref(O), {
+                  as: "span",
+                  class: "celeste-checkbox-label-label"
+                }, {
+                  default: withCtx(() => [
+                    renderSlot(_ctx.$slots, "label", {}, void 0, true)
+                  ]),
+                  _: 3
+                }),
+                _ctx.$slots.sublabel ? (openBlock(), createBlock(unref(O), {
+                  key: 0,
+                  as: "span",
+                  class: "celeste-checkbox-label-sublabel"
+                }, {
+                  default: withCtx(() => [
+                    renderSlot(_ctx.$slots, "sublabel", {}, void 0, true)
+                  ]),
+                  _: 3
+                })) : createCommentVNode("", true)
+              ]),
+              _ctx.$slots.badge ? (openBlock(), createBlock(unref(O), {
+                key: 0,
+                "as-child": "",
+                class: "celeste-checkbox-label-badge"
+              }, {
+                default: withCtx(() => [
+                  renderSlot(_ctx.$slots, "badge", {}, void 0, true)
+                ]),
+                _: 3
+              })) : createCommentVNode("", true)
+            ]),
+            createElementVNode("div", _hoisted_3, [
+              _ctx.$slots.description ? (openBlock(), createBlock(unref(O), {
+                key: 0,
+                as: "span",
+                class: "celeste-checkbox-label-description"
+              }, {
+                default: withCtx(() => [
+                  renderSlot(_ctx.$slots, "description", {}, void 0, true)
+                ]),
+                _: 3
+              })) : createCommentVNode("", true),
+              _ctx.$slots.linkButton ? (openBlock(), createBlock(unref(O), {
+                key: 1,
+                "as-child": "",
+                class: "celeste-checkbox-label-link-button"
+              }, {
+                default: withCtx(() => [
+                  renderSlot(_ctx.$slots, "linkButton", {}, void 0, true)
+                ]),
+                _: 3
+              })) : createCommentVNode("", true)
+            ])
+          ])
+        ]),
+        _: 3
+      }, 16, ["aria-required", "aria-disabcled", "class"]);
+    };
+  }
+});
+const checkboxLabel = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-cddafe7b"]]);
+export {
+  checkboxLabel as default
+};

package/dist/es/checkbox.js

@@ -0,0 +1,4 @@
+import { _ as _sfc_main } from "./chunks/checkbox.vue_vue_type_style_index_0_lang.js";
+export {
+  _sfc_main as default
+};

package/dist/es/chunks/_plugin-vue_export-helper.js

@@ -0,0 +1,10 @@
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+export {
+  _export_sfc as _
+};

package/dist/es/chunks/alpha-slider.js

@@ -0,0 +1,128 @@
+import { defineComponent, useTemplateRef, computed, onUnmounted, openBlock, createElementBlock, createElementVNode, normalizeStyle } from "vue";
+import { useUserPageSelection } from "../use-user-select.js";
+import { getAbsolutePosition, getPageXYFromEvent, resolveArrowDirection } from "../color.js";
+import { d as defineColorModel } from "./use-color-model.js";
+const _hoisted_1 = { class: "celeste-color-slider" };
+const _hoisted_2 = ["aria-valuenow"];
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "alpha-slider",
+  props: {
+    modelValue: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const tinyColorRef = defineColorModel(props, emit);
+    const { preventPageUserSelect, allowPageUserSelect } = useUserPageSelection();
+    const containerRef = useTemplateRef("slider-track");
+    const alpha = computed(() => tinyColorRef.value.getAlpha());
+    const alphaSliderBg = computed(() => {
+      const { r, g, b } = tinyColorRef.value.toRgb();
+      return `
+    linear-gradient(to right, rgba(${r}, ${g}, ${b}, 0), rgba(${r}, ${g}, ${b}, 1)),
+      repeating-conic-gradient(
+        #ffffff 0deg,
+        #ffffff 90deg,
+        rgba(0, 0, 0, 0.3) 90deg,
+        rgba(0, 0, 0, 0.3) 180deg
+      ) 0% -25% / 6px 6px
+  `;
+    });
+    const trackThumbBg = computed(() => {
+      const { r, g, b, a } = tinyColorRef.value.toRgb();
+      const rgbaString = [r, g, b, a].join(",");
+      return `rgba(${rgbaString})`;
+    });
+    function handleChange(e, skip = false) {
+      if (!skip) {
+        e.preventDefault();
+      }
+      const container = containerRef.value;
+      if (!container) {
+        return;
+      }
+      const containerWidth = container.clientWidth;
+      const { x: xOffset } = getAbsolutePosition(container);
+      const { x: pageX } = getPageXYFromEvent(e);
+      const left = pageX - xOffset;
+      let a;
+      if (left < 0) {
+        a = 0;
+      } else if (left > containerWidth) {
+        a = 1;
+      } else {
+        a = Math.round(left * 100 / containerWidth) / 100;
+      }
+      if (alpha.value !== a) {
+        tinyColorRef.value = tinyColorRef.value.setAlpha(a).clone();
+      }
+    }
+    function handleMouseDown(e) {
+      handleChange(e, true);
+      preventPageUserSelect();
+      window.addEventListener("mousemove", handleChange);
+      window.addEventListener("mouseup", handleMouseUp);
+    }
+    function handleMouseUp() {
+      allowPageUserSelect();
+      unbindEventListeners();
+    }
+    function unbindEventListeners() {
+      window.removeEventListener("mousemove", handleChange);
+      window.removeEventListener("mouseup", handleMouseUp);
+    }
+    function handleKeydown(e) {
+      const direction = resolveArrowDirection(e);
+      if (!direction) {
+        return;
+      }
+      e.preventDefault();
+      const currentValue = alpha.value;
+      let newValue;
+      switch (direction) {
+        case "left": {
+          newValue = currentValue - 0.1 < 0 ? 0 : currentValue - 0.1;
+          break;
+        }
+        case "right": {
+          newValue = currentValue + 0.1 > 1 ? 1 : currentValue + 0.1;
+          break;
+        }
+      }
+      if (typeof newValue !== "undefined") {
+        tinyColorRef.value = tinyColorRef.value.setAlpha(newValue).clone();
+      }
+    }
+    onUnmounted(() => {
+      unbindEventListeners();
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        createElementVNode("div", {
+          ref: "slider-track",
+          class: "slider-track",
+          style: normalizeStyle({ background: alphaSliderBg.value }),
+          role: "slider",
+          "aria-label": "Transparency",
+          "aria-valuemax": "1",
+          "aria-valuemin": "0",
+          "aria-valuenow": alpha.value.toFixed(1),
+          tabindex: "0",
+          onMousedown: handleMouseDown,
+          onTouchmovePassive: handleChange,
+          onTouchstartPassive: handleChange,
+          onKeydown: handleKeydown
+        }, [
+          createElementVNode("div", {
+            class: "celeste-color-thumb",
+            style: normalizeStyle({ left: `${alpha.value * 100}%`, background: trackThumbBg.value })
+          }, null, 4)
+        ], 44, _hoisted_2)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/es/chunks/checkbox.vue_vue_type_style_index_0_lang.js

@@ -0,0 +1,39 @@
+import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, createVNode } from "vue";
+import { useDelegatedProps } from "../use-delegated-props.js";
+import { c as clsx } from "./clsx.js";
+import { x as xe, z as zv, K as Kv } from "./index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "checkbox",
+  props: {
+    defaultChecked: { type: Boolean },
+    checked: { type: [Boolean, String] },
+    disabled: { type: Boolean },
+    required: { type: Boolean },
+    name: {},
+    value: {},
+    id: {},
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  emits: ["update:checked"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const delegatedProps = useDelegatedProps(props, "class");
+    const forwarded = xe(delegatedProps, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(zv), mergeProps(unref(forwarded), {
+        class: unref(clsx)("celeste-checkbox", props.class)
+      }), {
+        default: withCtx(() => [
+          createVNode(unref(Kv), { class: "celeste-checkbox-indicator" })
+        ]),
+        _: 1
+      }, 16, ["class"]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/es/chunks/clsx.js

@@ -0,0 +1,16 @@
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+export {
+  clsx as c
+};

package/dist/es/chunks/combobox-anchor.js

@@ -0,0 +1,32 @@
+import { defineComponent, computed, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+import { c as clsx } from "./clsx.js";
+import { A as At, j as jv } from "./index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "combobox-anchor",
+  props: {
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = computed(() => {
+      const { class: _, ...delegated } = props;
+      return delegated;
+    });
+    const forwarded = At(delegatedProps);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(jv), mergeProps(unref(forwarded), {
+        class: unref(clsx)(props.class, "celeste-dropdown-anchor")
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/es/chunks/content-divider.vue_vue_type_style_index_0_lang.js

@@ -0,0 +1,53 @@
+import { defineComponent, openBlock, createBlock, unref, normalizeClass, withCtx, createElementBlock, createCommentVNode, toDisplayString, createElementVNode, createTextVNode } from "vue";
+import { c as clsx } from "./clsx.js";
+import { Q as Qf } from "./index.js";
+const _hoisted_1 = {
+  key: 0,
+  class: "celecte-content-divider-type-line"
+};
+const _hoisted_2 = {
+  key: 1,
+  class: "celecte-content-divider-type-text"
+};
+const _hoisted_3 = {
+  key: 2,
+  class: "celecte-content-divider-type-text-line"
+};
+const _hoisted_4 = {
+  key: 3,
+  class: "celecte-content-divider-type-solid-text"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "content-divider",
+  props: {
+    class: {},
+    type: { default: "line" },
+    text: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Qf), {
+        "aria-label": "divider",
+        class: normalizeClass([unref(clsx)("celeste-celecte-content-divider", props.class), "celecte-content-divider"])
+      }, {
+        default: withCtx(() => [
+          _ctx.type === "line" ? (openBlock(), createElementBlock("div", _hoisted_1)) : createCommentVNode("", true),
+          _ctx.type === "text" && _ctx.text ? (openBlock(), createElementBlock("div", _hoisted_2, toDisplayString(_ctx.text), 1)) : createCommentVNode("", true),
+          _ctx.type === "text-line" && _ctx.text ? (openBlock(), createElementBlock("div", _hoisted_3, [
+            _cache[0] || (_cache[0] = createElementVNode("hr", null, null, -1)),
+            _cache[1] || (_cache[1] = createTextVNode()),
+            createElementVNode("span", null, toDisplayString(_ctx.text), 1),
+            _cache[2] || (_cache[2] = createTextVNode()),
+            _cache[3] || (_cache[3] = createElementVNode("hr", null, null, -1))
+          ])) : createCommentVNode("", true),
+          _ctx.type === "solid-text" && _ctx.text ? (openBlock(), createElementBlock("div", _hoisted_4, toDisplayString(_ctx.text), 1)) : createCommentVNode("", true)
+        ]),
+        _: 1
+      }, 8, ["class"]);
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/es/chunks/dropdown-menu-content.vue_vue_type_style_index_0_lang.js

@@ -0,0 +1,52 @@
+import { defineComponent, openBlock, createBlock, unref, withCtx, createVNode, mergeProps, renderSlot } from "vue";
+import { useDelegatedProps } from "../use-delegated-props.js";
+import { c as clsx } from "./clsx.js";
+import { x as xe, i as ih, u as uh } from "./index.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "dropdown-menu-content",
+  props: {
+    forceMount: { type: Boolean },
+    loop: { type: Boolean },
+    side: {},
+    sideOffset: { default: 4 },
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    updatePositionStrategy: {},
+    prioritizePosition: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "closeAutoFocus"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const delegatedProps = useDelegatedProps(props, "class");
+    const forwarded = xe(delegatedProps, emits);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(ih), null, {
+        default: withCtx(() => [
+          createVNode(unref(uh), mergeProps(unref(forwarded), {
+            "force-mount": "",
+            class: unref(clsx)("celeste-dropdown-menu-content", props.class)
+          }), {
+            default: withCtx(() => [
+              renderSlot(_ctx.$slots, "default")
+            ]),
+            _: 3
+          }, 16, ["class"])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+export {
+  _sfc_main as _
+};