ep-craft 0.1.33 → 0.1.35

package/dist/components/button/index.d.ts

@@ -1,4 +1,16 @@
 import type { Plugin } from 'vue';
+import type { ButtonProps } from './button';
 import _EpButton from './EpButton.vue';
 export declare const EpButton: typeof _EpButton & Plugin;
 export default EpButton;
+/**
+ * button 契约补口（vendor-popover 需求 7.3）。
+ *
+ * - `buttonGroupContextKey` 必须来自本地 `constants.ts`，与 `EpButton` 的 inject
+ *   及 `EpButtonGroup` 的 provide 共用同一 Symbol。
+ * - `ButtonType` 由本地 `buttonProps.type` 派生，供 dropdown 的上游形态类型导入使用；
+ *   不改变 `buttonTypes` 的取值集合。
+ */
+export { buttonGroupContextKey } from './constants';
+export type { ButtonProps } from './button';
+export type ButtonType = NonNullable<ButtonProps['type']>;

package/dist/components/button-group/index.d.ts

@@ -1,4 +1,5 @@
 import type { Plugin } from 'vue';
-import { ElButtonGroup } from 'element-plus';
-export declare const EpButtonGroup: typeof ElButtonGroup & Plugin;
+import _EpButtonGroup from './src/button-group.vue';
+export declare const EpButtonGroup: typeof _EpButtonGroup & Plugin;
 export default EpButtonGroup;
+export * from './src/button-group';

package/dist/components/button-group/index.js

@@ -1,6 +1,10 @@
-import { ElButtonGroup as t } from "element-plus";
 import { withInstall as o } from "../../utils/with-install.js";
-const p = Object.assign({}, t, { name: "EpButtonGroup" }), u = o(p, "ep-button-group");
+import t from "./src/button-group.vue.js";
+import "./src/button-group.js";
+const i = o(
+  t,
+  "ep-button-group"
+);
 export {
-  u as EpButtonGroup
+  i as EpButtonGroup
 };

package/dist/components/button-group/src/button-group.d.ts

@@ -0,0 +1,48 @@
+import type { ExtractPublicPropTypes } from 'vue';
+import type { ButtonProps } from '../../button/button';
+export interface ButtonGroupProps {
+    /**
+     * @description control the size of buttons in this button-group
+     */
+    size?: ButtonProps['size'];
+    /**
+     * @description control the type of buttons in this button-group
+     */
+    type?: ButtonProps['type'];
+    /**
+     * @description display direction
+     */
+    direction?: 'horizontal' | 'vertical';
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `ButtonGroupProps` instead.
+ */
+export declare const buttonGroupProps: {
+    /**
+     * @description control the size of buttons in this button-group
+     */
+    readonly size: {
+        readonly type: import("vue").PropType<"" | "large" | "default" | "small" | "mini">;
+        readonly values: readonly ["", "large", "default", "small", "mini"];
+    };
+    /**
+     * @description control the type of buttons in this button-group
+     */
+    readonly type: {
+        readonly type: import("vue").PropType<typeof import("../../button/button").buttonTypes[number]>;
+        readonly values: readonly ["default", "primary", "success", "warning", "info", "danger", "text", ""];
+        readonly default: "";
+    };
+    /**
+     * @description display direction
+     */
+    readonly direction: {
+        readonly type: import("vue").PropType<"horizontal" | "vertical">;
+        readonly values: readonly ["horizontal", "vertical"];
+        readonly default: "horizontal";
+    };
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `ButtonGroupProps` instead.
+ */
+export type ButtonGroupPropsPublic = ExtractPublicPropTypes<typeof buttonGroupProps>;

package/dist/components/button-group/src/button-group.js

@@ -0,0 +1,7 @@
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "vue";
+import { buttonProps as t } from "../../button/button.js";
+t.size, t.type;

package/dist/components/button-group/src/button-group.vue.d.ts

@@ -0,0 +1,16 @@
+import type { ButtonGroupProps } from './button-group';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<ButtonGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ButtonGroupProps> & Readonly<{}>, {
+    direction: "horizontal" | "vertical";
+    type: import("../../button").ButtonProps["type"];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/button-group/src/button-group.vue.js

@@ -0,0 +1,42 @@
+import { defineComponent as m, provide as n, reactive as s, toRef as e, openBlock as u, createElementBlock as a, normalizeClass as c, unref as r, renderSlot as l } from "vue";
+import { useNamespace as f } from "../../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import "@element-plus/icons-vue";
+import "../../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { buttonGroupContextKey as d } from "../../button/constants.js";
+const R = /* @__PURE__ */ m({
+  name: "EpButtonGroup",
+  __name: "button-group",
+  props: {
+    size: {},
+    type: { default: "" },
+    direction: { default: "horizontal" }
+  },
+  setup(p) {
+    const t = p;
+    n(
+      d,
+      s({
+        size: e(t, "size"),
+        type: e(t, "type")
+      })
+    );
+    const o = f("button");
+    return (i, b) => (u(), a("div", {
+      class: c([r(o).b("group"), r(o).bm("group", t.direction)])
+    }, [
+      l(i.$slots, "default")
+    ], 2));
+  }
+});
+export {
+  R as default
+};

package/dist/components/button-group/src/button-group2.vue.js

@@ -0,0 +1,4 @@
+import f from "./button-group.vue.js";
+export {
+  f as default
+};

package/dist/components/carousel/EpCarousel.vue.d.ts

@@ -0,0 +1,39 @@
+import type { CarouselProps } from './carousel';
+declare var __VLS_29: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_29) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<CarouselProps, {
+    /** @description active slide index */
+    activeIndex: import("vue").WritableComputedRef<number, number>;
+    /** @description manually switch slide, index of the slide to be switched to, starting from 0; or the `name` of corresponding `el-carousel-item` */
+    setActiveItem: (index: number | string) => void;
+    /** @description switch to the previous slide */
+    prev: () => void;
+    /** @description switch to the next slide */
+    next: () => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (current: number, prev: number) => void;
+}, string, import("vue").PublicProps, Readonly<CarouselProps> & Readonly<{
+    onChange?: ((current: number, prev: number) => any) | undefined;
+}>, {
+    direction: "horizontal" | "vertical";
+    height: string;
+    type: "" | "card";
+    arrow: "always" | "hover" | "never";
+    trigger: "hover" | "click";
+    loop: boolean;
+    initialIndex: number;
+    autoplay: boolean;
+    interval: number;
+    indicatorPosition: "" | "none" | "outside";
+    cardScale: number;
+    pauseOnHover: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/carousel/EpCarousel.vue.js

@@ -0,0 +1,227 @@
+import { defineComponent as te, computed as L, unref as e, openBlock as s, createElementBlock as c, withModifiers as f, normalizeClass as u, createBlock as A, Transition as N, withCtx as v, withDirectives as C, createElementVNode as n, createVNode as m, vShow as k, createCommentVNode as h, normalizeStyle as oe, renderSlot as re, Fragment as ie, renderList as ne, toDisplayString as ae } from "vue";
+import { ElIcon as x } from "../icon/index.js";
+import { ArrowLeft as se, ArrowRight as le } from "@element-plus/icons-vue";
+import { useNamespace as ue } from "../../hooks/use-namespace/index.js";
+import "@vue/shared";
+import "lodash-unified";
+import "@vueuse/core";
+import { useLocale as de } from "../../hooks/use-locale/index.js";
+import "../../hooks/use-size/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import "../../hooks/use-delayed-toggle/index.js";
+import "../../hooks/use-aria/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "../../hooks/use-empty-values/index.js";
+import { carouselEmits as ce } from "./carousel.js";
+import { useCarousel as me } from "./use-carousel.js";
+const pe = ["aria-label"], fe = ["aria-label"], ve = ["onMouseenter", "onClick"], he = ["aria-label"], we = { key: 0 }, ye = {
+  key: 2,
+  xmlns: "http://www.w3.org/2000/svg",
+  version: "1.1",
+  style: { display: "none" }
+}, P = "EpCarousel", Ve = /* @__PURE__ */ te({
+  name: P,
+  __name: "EpCarousel",
+  props: {
+    initialIndex: { default: 0 },
+    height: { default: "" },
+    trigger: { default: "hover" },
+    autoplay: { type: Boolean, default: !0 },
+    interval: { default: 3e3 },
+    indicatorPosition: { default: "" },
+    arrow: { default: "hover" },
+    type: { default: "" },
+    cardScale: { default: 0.83 },
+    loop: { type: Boolean, default: !0 },
+    direction: { default: "horizontal" },
+    pauseOnHover: { type: Boolean, default: !0 },
+    motionBlur: { type: Boolean }
+  },
+  emits: ce,
+  setup(a, { expose: D, emit: V }) {
+    const l = a, z = V, {
+      root: G,
+      activeIndex: p,
+      exposeActiveIndex: H,
+      arrowDisplay: b,
+      hasLabel: B,
+      hover: M,
+      isCardType: O,
+      items: E,
+      isVertical: w,
+      containerStyle: F,
+      handleButtonEnter: S,
+      handleButtonLeave: y,
+      handleIndicatorClick: R,
+      handleMouseEnter: $,
+      handleMouseLeave: I,
+      setActiveItem: j,
+      prev: q,
+      next: J,
+      PlaceholderItem: K,
+      isTwoLengthShow: Q,
+      ItemsSorter: U,
+      throttledArrowClick: T,
+      throttledIndicatorHover: W
+    } = me(l, z, P), t = ue("carousel"), { t: g } = de(), X = L(() => {
+      const r = [t.b(), t.m(l.direction)];
+      return e(O) && r.push(t.m("card")), r.push(
+        t.is(
+          "vertical-outside",
+          e(w) && l.indicatorPosition === "outside"
+        )
+      ), r;
+    }), Y = L(() => {
+      const r = [t.e("indicators"), t.em("indicators", l.direction)];
+      return e(B) && r.push(t.em("indicators", "labels")), l.indicatorPosition === "outside" && r.push(t.em("indicators", "outside")), e(w) && r.push(t.em("indicators", "right")), r;
+    });
+    function Z(r) {
+      if (!l.motionBlur) return;
+      const o = e(w) ? `${t.namespace.value}-transitioning-vertical` : `${t.namespace.value}-transitioning`;
+      r.currentTarget.classList.add(o);
+    }
+    function _(r) {
+      if (!l.motionBlur) return;
+      const o = e(w) ? `${t.namespace.value}-transitioning-vertical` : `${t.namespace.value}-transitioning`;
+      r.currentTarget.classList.remove(o);
+    }
+    return D({
+      /** @description active slide index */
+      activeIndex: H,
+      /** @description manually switch slide, index of the slide to be switched to, starting from 0; or the `name` of corresponding `el-carousel-item` */
+      setActiveItem: j,
+      /** @description switch to the previous slide */
+      prev: q,
+      /** @description switch to the next slide */
+      next: J
+    }), (r, o) => (s(), c("div", {
+      ref_key: "root",
+      ref: G,
+      class: u(X.value),
+      onMouseenter: o[6] || (o[6] = f(
+        //@ts-ignore
+        (...i) => e($) && e($)(...i),
+        ["stop"]
+      )),
+      onMouseleave: o[7] || (o[7] = f(
+        //@ts-ignore
+        (...i) => e(I) && e(I)(...i),
+        ["stop"]
+      ))
+    }, [
+      e(b) ? (s(), A(N, {
+        key: 0,
+        name: "carousel-arrow-left"
+      }, {
+        default: v(() => [
+          C(n("button", {
+            type: "button",
+            class: u([e(t).e("arrow"), e(t).em("arrow", "left")]),
+            "aria-label": e(g)("el.carousel.leftArrow"),
+            onMouseenter: o[0] || (o[0] = (i) => e(S)("left")),
+            onMouseleave: o[1] || (o[1] = //@ts-ignore
+            (...i) => e(y) && e(y)(...i)),
+            onClick: o[2] || (o[2] = f((i) => e(T)(e(p) - 1), ["stop"]))
+          }, [
+            m(e(x), null, {
+              default: v(() => [
+                m(e(se))
+              ]),
+              _: 1
+            })
+          ], 42, pe), [
+            [k, (a.arrow === "always" || e(M)) && (a.loop || e(p) > 0)]
+          ])
+        ]),
+        _: 1
+      })) : h("", !0),
+      e(b) ? (s(), A(N, {
+        key: 1,
+        name: "carousel-arrow-right"
+      }, {
+        default: v(() => [
+          C(n("button", {
+            type: "button",
+            class: u([e(t).e("arrow"), e(t).em("arrow", "right")]),
+            "aria-label": e(g)("el.carousel.rightArrow"),
+            onMouseenter: o[3] || (o[3] = (i) => e(S)("right")),
+            onMouseleave: o[4] || (o[4] = //@ts-ignore
+            (...i) => e(y) && e(y)(...i)),
+            onClick: o[5] || (o[5] = f((i) => e(T)(e(p) + 1), ["stop"]))
+          }, [
+            m(e(x), null, {
+              default: v(() => [
+                m(e(le))
+              ]),
+              _: 1
+            })
+          ], 42, fe), [
+            [
+              k,
+              (a.arrow === "always" || e(M)) && (a.loop || e(p) < e(E).length - 1)
+            ]
+          ])
+        ]),
+        _: 1
+      })) : h("", !0),
+      n("div", {
+        class: u(e(t).e("container")),
+        style: oe(e(F)),
+        onTransitionstart: Z,
+        onTransitionend: _
+      }, [
+        m(e(K)),
+        re(r.$slots, "default")
+      ], 38),
+      m(e(U), null, {
+        default: v(() => [
+          a.indicatorPosition !== "none" ? (s(), c("ul", {
+            key: 0,
+            class: u(Y.value)
+          }, [
+            (s(!0), c(ie, null, ne(e(E), (i, d) => C((s(), c("li", {
+              key: d,
+              class: u([
+                e(t).e("indicator"),
+                e(t).em("indicator", a.direction),
+                e(t).is("active", d === e(p))
+              ]),
+              onMouseenter: (ee) => e(W)(d),
+              onClick: f((ee) => e(R)(d), ["stop"])
+            }, [
+              n("button", {
+                class: u(e(t).e("button")),
+                "aria-label": e(g)("el.carousel.indicator", { index: d + 1 })
+              }, [
+                e(B) ? (s(), c("span", we, ae(i.props.label), 1)) : h("", !0)
+              ], 10, he)
+            ], 42, ve)), [
+              [k, e(Q)(d)]
+            ])), 128))
+          ], 2)) : h("", !0)
+        ]),
+        _: 1
+      }),
+      a.motionBlur ? (s(), c("svg", ye, [...o[8] || (o[8] = [
+        n("defs", null, [
+          n("filter", { id: "elCarouselHorizontal" }, [
+            n("feGaussianBlur", {
+              in: "SourceGraphic",
+              stdDeviation: "12,0"
+            })
+          ]),
+          n("filter", { id: "elCarouselVertical" }, [
+            n("feGaussianBlur", {
+              in: "SourceGraphic",
+              stdDeviation: "0,10"
+            })
+          ])
+        ], -1)
+      ])])) : h("", !0)
+    ], 34));
+  }
+});
+export {
+  Ve as default
+};

package/dist/components/carousel/EpCarousel2.vue.js

@@ -0,0 +1,4 @@
+import f from "./EpCarousel.vue.js";
+export {
+  f as default
+};

package/dist/components/carousel/carousel.d.ts

@@ -0,0 +1,86 @@
+import type { ExtractPublicPropTypes } from 'vue';
+export interface CarouselProps {
+    /**
+     * @description index of the initially active slide (starting from 0)
+     */
+    initialIndex?: number;
+    /**
+     * @description height of the carousel
+     */
+    height?: string;
+    /**
+     * @description how indicators are triggered
+     */
+    trigger?: 'hover' | 'click';
+    /**
+     * @description whether automatically loop the slides
+     */
+    autoplay?: boolean;
+    /**
+     * @description interval of the auto loop, in milliseconds
+     */
+    interval?: number;
+    /**
+     * @description position of the indicators
+     */
+    indicatorPosition?: '' | 'none' | 'outside';
+    /**
+     * @description when arrows are shown
+     */
+    arrow?: 'always' | 'hover' | 'never';
+    /**
+     * @description type of the Carousel
+     */
+    type?: '' | 'card';
+    /**
+     * @description when type is card, scaled size of secondary cards
+     */
+    cardScale?: number;
+    /**
+     * @description display the items in loop
+     */
+    loop?: boolean;
+    /**
+     * @description display direction
+     */
+    direction?: 'horizontal' | 'vertical';
+    /**
+     * @description pause autoplay when hover
+     */
+    pauseOnHover?: boolean;
+    /**
+     * @description infuse dynamism and smoothness into the carousel
+     */
+    motionBlur?: boolean;
+}
+/**
+ * @deprecated Removed after 3.0.0, Use `CarouselProps` instead.
+ */
+export declare const carouselProps: {
+    readonly initialIndex: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+    readonly height: import("@element-plus/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly trigger: import("@element-plus/utils").EpPropFinalized<StringConstructor, "click" | "hover", unknown, "hover", boolean>;
+    readonly autoplay: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly interval: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 3000, boolean>;
+    readonly indicatorPosition: import("@element-plus/utils").EpPropFinalized<StringConstructor, "" | "none" | "outside", unknown, "", boolean>;
+    readonly arrow: import("@element-plus/utils").EpPropFinalized<StringConstructor, "always" | "never" | "hover", unknown, "hover", boolean>;
+    readonly type: import("@element-plus/utils").EpPropFinalized<StringConstructor, "" | "card", unknown, "", boolean>;
+    readonly cardScale: import("@element-plus/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0.83, boolean>;
+    readonly loop: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly direction: import("@element-plus/utils").EpPropFinalized<StringConstructor, "horizontal" | "vertical", unknown, "horizontal", boolean>;
+    readonly pauseOnHover: import("@element-plus/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly motionBlur: BooleanConstructor;
+};
+export declare const carouselEmits: {
+    /**
+     * @description triggers when the active slide switches
+     * @param current index of the new active slide
+     * @param prev index of the old active slide
+     */
+    change: (current: number, prev: number) => boolean;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `CarouselProps` instead.
+ */
+export type CarouselPropsPublic = ExtractPublicPropTypes<typeof carouselProps>;
+export type CarouselEmits = typeof carouselEmits;

package/dist/components/carousel/carousel.js

@@ -0,0 +1,113 @@
+import { isNumber as r } from "../../utils/types.js";
+import "lodash-unified";
+import "@vueuse/core";
+import "@vue/shared";
+import "@element-plus/icons-vue";
+import { buildProps as o } from "../../utils/vue/props/runtime.js";
+import "vue";
+const s = o({
+  /**
+   * @description index of the initially active slide (starting from 0)
+   */
+  initialIndex: {
+    type: Number,
+    default: 0
+  },
+  /**
+   * @description height of the carousel
+   */
+  height: {
+    type: String,
+    default: ""
+  },
+  /**
+   * @description how indicators are triggered
+   */
+  trigger: {
+    type: String,
+    values: ["hover", "click"],
+    default: "hover"
+  },
+  /**
+   * @description whether automatically loop the slides
+   */
+  autoplay: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description interval of the auto loop, in milliseconds
+   */
+  interval: {
+    type: Number,
+    default: 3e3
+  },
+  /**
+   * @description position of the indicators
+   */
+  indicatorPosition: {
+    type: String,
+    values: ["", "none", "outside"],
+    default: ""
+  },
+  /**
+   * @description when arrows are shown
+   */
+  arrow: {
+    type: String,
+    values: ["always", "hover", "never"],
+    default: "hover"
+  },
+  /**
+   * @description type of the Carousel
+   */
+  type: {
+    type: String,
+    values: ["", "card"],
+    default: ""
+  },
+  /**
+   * @description when type is card, scaled size of secondary cards
+   */
+  cardScale: {
+    type: Number,
+    default: 0.83
+  },
+  /**
+   * @description display the items in loop
+   */
+  loop: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description display direction
+   */
+  direction: {
+    type: String,
+    values: ["horizontal", "vertical"],
+    default: "horizontal"
+  },
+  /**
+   * @description pause autoplay when hover
+   */
+  pauseOnHover: {
+    type: Boolean,
+    default: !0
+  },
+  /**
+   * @description infuse dynamism and smoothness into the carousel
+   */
+  motionBlur: Boolean
+}), y = {
+  /**
+   * @description triggers when the active slide switches
+   * @param current index of the new active slide
+   * @param prev index of the old active slide
+   */
+  change: (e, t) => [e, t].every(r)
+};
+export {
+  y as carouselEmits,
+  s as carouselProps
+};

package/dist/components/carousel/constants.d.ts

@@ -0,0 +1,32 @@
+import type { InjectionKey, Ref, VNode } from 'vue';
+import type { CarouselItemProps } from '../carousel-item/carousel-item';
+export type CarouselItemStates = {
+    hover: boolean;
+    translate: number;
+    scale: number;
+    active: boolean;
+    ready: boolean;
+    inStage: boolean;
+    animating: boolean;
+};
+export type CarouselItemContext = {
+    props: Required<CarouselItemProps>;
+    states: CarouselItemStates;
+    uid: number;
+    getVnode: () => VNode;
+    translateItem: (index: number, activeIndex: number, oldIndex?: number) => void;
+};
+export type CarouselContext = {
+    root: Ref<HTMLElement | undefined>;
+    items: Ref<CarouselItemContext[]>;
+    isCardType: Ref<boolean>;
+    isVertical: Ref<boolean>;
+    loop: boolean;
+    cardScale: number;
+    addItem: (item: CarouselItemContext) => void;
+    removeItem: (item: CarouselItemContext) => void;
+    setActiveItem: (index: number) => void;
+    setContainerHeight: (height: number) => void;
+};
+export declare const carouselContextKey: InjectionKey<CarouselContext>;
+export declare const CAROUSEL_ITEM_NAME = "EpCarouselItem";

package/dist/components/carousel/constants.js

@@ -0,0 +1,5 @@
+const e = Symbol("carouselContextKey"), o = "EpCarouselItem";
+export {
+  o as CAROUSEL_ITEM_NAME,
+  e as carouselContextKey
+};