vft 0.0.428 → 0.0.430

package/es/components/popper/trigger.vue2.js

@@ -0,0 +1,117 @@
+import { defineComponent as g, getCurrentInstance as C, inject as y, computed as s, onMounted as x, watch as l, onBeforeUnmount as E, createBlock as B, createCommentVNode as w, openBlock as A, unref as M, mergeProps as P, withCtx as R, renderSlot as T } from "vue";
+import { isElement as v } from "@vft/utils";
+import { OnlyChild as k } from "../slot/only-child.js";
+import { unrefElement as L } from "@vueuse/core";
+import "../config-provider/hooks/use-global-config.js";
+import { isNil as F } from "lodash-es";
+import "../form/index.js";
+import { useForwardRef as I } from "../../hooks/use-forward-ref/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import { POPPER_INJECTION_KEY as K } from "./constants.js";
+const O = g({
+  name: "VftPopperTrigger",
+  inheritAttrs: !1
+}), z = /* @__PURE__ */ g({
+  ...O,
+  props: {
+    virtualRef: {},
+    virtualTriggering: { type: Boolean },
+    onMouseenter: {},
+    onMouseleave: {},
+    onClick: {},
+    onKeydown: {},
+    onFocus: {},
+    onBlur: {},
+    onContextmenu: {},
+    id: {},
+    open: { type: Boolean }
+  },
+  setup(r, { expose: b }) {
+    const h = C(), { role: i, triggerRef: n } = y(K, void 0);
+    I(n);
+    const p = s(() => u.value ? r.id : void 0), c = s(() => {
+      if (i && i.value === "tooltip")
+        return r.open && r.id ? r.id : void 0;
+    }), u = s(() => {
+      if (i && i.value !== "tooltip")
+        return i.value;
+    }), m = s(() => u.value ? `${r.open}` : void 0);
+    let a;
+    return x(() => {
+      l(
+        () => r.virtualRef,
+        (e) => {
+          e && (n.value = L(e));
+        },
+        {
+          immediate: !0
+        }
+      ), l(
+        n,
+        (e, d) => {
+          a?.(), a = void 0, v(e) && ([
+            "onMouseenter",
+            "onMouseleave",
+            "onClick",
+            "onKeydown",
+            "onFocus",
+            "onBlur",
+            "onContextmenu"
+          ].forEach((o) => {
+            const t = h.props[o];
+            t && (e.addEventListener(
+              o.slice(2).toLowerCase(),
+              t
+            ), d?.removeEventListener?.(
+              o.slice(2).toLowerCase(),
+              t
+            ));
+          }), a = l(
+            [p, c, u, m],
+            (o) => {
+              [
+                "aria-controls",
+                "aria-describedby",
+                "aria-haspopup",
+                "aria-expanded"
+              ].forEach((t, f) => {
+                F(o[f]) ? e.removeAttribute(t) : e.setAttribute(t, o[f]);
+              });
+            },
+            { immediate: !0 }
+          )), v(d) && [
+            "aria-controls",
+            "aria-describedby",
+            "aria-haspopup",
+            "aria-expanded"
+          ].forEach((o) => d.removeAttribute(o));
+        },
+        {
+          immediate: !0
+        }
+      );
+    }), E(() => {
+      a?.(), a = void 0;
+    }), b({
+      /**
+       * @description trigger element
+       */
+      triggerRef: n
+    }), (e, d) => r.virtualTriggering ? w("", !0) : (A(), B(M(k), P({ key: 0 }, e.$attrs, {
+      "aria-controls": p.value,
+      "aria-describedby": c.value,
+      "aria-expanded": m.value,
+      "aria-haspopup": u.value
+    }), {
+      default: R(() => [
+        T(e.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["aria-controls", "aria-describedby", "aria-expanded", "aria-haspopup"]));
+  }
+});
+export {
+  z as default
+};

package/es/components/progress/progress.vue2.js

@@ -0,0 +1,167 @@
+import { defineComponent as T, computed as r, createElementBlock as i, openBlock as o, normalizeClass as l, unref as a, createCommentVNode as y, createElementVNode as f, normalizeStyle as c, renderSlot as C, toDisplayString as D, createBlock as A, normalizeProps as L, mergeProps as M } from "vue";
+import { isFunction as E, isString as I } from "@vft/utils";
+import { VftIcon as O } from "../icon/index.js";
+import "@vueuse/core";
+import "../config-provider/hooks/use-global-config.js";
+import "lodash-es";
+import "../form/index.js";
+import { useNamespace as R } from "../../hooks/use-namespace/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+const U = ["aria-valuenow"], j = { viewBox: "0 0 100 100" }, q = ["d", "stroke", "stroke-width"], G = ["d", "stroke", "opacity", "stroke-linecap", "stroke-width"], H = { key: 0 }, J = T({
+  name: "vft-progress"
+}), re = /* @__PURE__ */ T({
+  ...J,
+  props: {
+    type: { default: "line" },
+    percentage: { default: 0 },
+    status: { default: "" },
+    indeterminate: { type: Boolean, default: !1 },
+    duration: { default: 3 },
+    strokeWidth: { default: 6 },
+    strokeLinecap: { default: "round" },
+    textInside: { type: Boolean, default: !1 },
+    width: { default: 126 },
+    showText: { type: Boolean, default: !0 },
+    color: { type: [String, Array, Function], default: "" },
+    striped: { type: Boolean, default: !1 },
+    stripedFlow: { type: Boolean, default: !1 },
+    format: { type: Function, default: (e) => `${e}%` }
+  },
+  setup(e) {
+    const n = R("progress"), g = {
+      success: "#13ce66",
+      exception: "#ff4949",
+      warning: "#e6a23c",
+      default: "#20a0ff"
+    }, F = r(() => ({
+      width: `${e.percentage}%`,
+      animationDuration: `${e.duration}s`,
+      backgroundColor: B(e.percentage)
+    })), h = r(
+      () => (e.strokeWidth / e.width * 100).toFixed(1)
+    ), $ = r(() => ["circle", "dashboard"].includes(e.type) ? Number.parseInt(
+      `${50 - Number.parseFloat(h.value) / 2}`,
+      10
+    ) : 0), b = r(() => {
+      const t = $.value, s = e.type === "dashboard";
+      return `
+          M 50 50
+          m 0 ${s ? "" : "-"}${t}
+          a ${t} ${t} 0 1 1 0 ${s ? "-" : ""}${t * 2}
+          a ${t} ${t} 0 1 1 0 ${s ? "" : "-"}${t * 2}
+          `;
+    }), u = r(() => 2 * Math.PI * $.value), m = r(() => e.type === "dashboard" ? 0.75 : 1), w = r(() => `${-1 * u.value * (1 - m.value) / 2}px`), P = r(() => ({
+      strokeDasharray: `${u.value * m.value}px, ${u.value}px`,
+      strokeDashoffset: w.value
+    })), N = r(() => ({
+      strokeDasharray: `${u.value * m.value * (e.percentage / 100)}px, ${u.value}px`,
+      strokeDashoffset: w.value,
+      transition: "stroke-dasharray 0.6s ease 0s, stroke 0.6s ease, opacity ease 0.6s"
+    })), z = r(() => {
+      let t;
+      return e.color ? t = B(e.percentage) : t = g[e.status] || g.default, t;
+    }), x = r(() => e.status === "warning" ? "icon-warning-filled" : e.type === "line" ? e.status === "success" ? "icon-circle-check" : "icon-circle-close" : e.status === "success" ? "icon-check" : "icon-close"), W = r(() => e.type === "line" ? 12 + e.strokeWidth * 0.4 : e.width * 0.111111 + 2), S = r(() => e.format(e.percentage));
+    function V(t) {
+      const s = 100 / t.length;
+      return t.map((d, k) => I(d) ? {
+        color: d,
+        percentage: (k + 1) * s
+      } : d).sort((d, k) => d.percentage - k.percentage);
+    }
+    const B = (t) => {
+      if (E(e.color))
+        return e.color(t);
+      if (I(e.color))
+        return e.color;
+      {
+        const s = V(e.color);
+        for (const v of s)
+          if (v.percentage > t) return v.color;
+        return s[s.length - 1]?.color;
+      }
+    };
+    return (t, s) => (o(), i("div", {
+      class: l([
+        a(n).b(),
+        a(n).m(e.type),
+        a(n).is(e.status),
+        {
+          [a(n).m("without-text")]: !e.showText,
+          [a(n).m("text-inside")]: e.textInside
+        }
+      ]),
+      role: "progressbar",
+      "aria-valuenow": e.percentage,
+      "aria-valuemin": "0",
+      "aria-valuemax": "100"
+    }, [
+      e.type === "line" ? (o(), i("div", {
+        key: 0,
+        class: l(a(n).b("bar"))
+      }, [
+        f("div", {
+          class: l(a(n).be("bar", "outer")),
+          style: c({ height: `${e.strokeWidth}px` })
+        }, [
+          f("div", {
+            class: l([
+              a(n).be("bar", "inner"),
+              { [a(n).bem("bar", "inner", "indeterminate")]: e.indeterminate },
+              { [a(n).bem("bar", "inner", "striped")]: e.striped },
+              { [a(n).bem("bar", "inner", "striped-flow")]: e.stripedFlow }
+            ]),
+            style: c(F.value)
+          }, [
+            (e.showText || t.$slots.default) && e.textInside ? (o(), i("div", {
+              key: 0,
+              class: l(a(n).be("bar", "innerText"))
+            }, [
+              C(t.$slots, "default", { percentage: e.percentage }, () => [
+                f("span", null, D(S.value), 1)
+              ])
+            ], 2)) : y("", !0)
+          ], 6)
+        ], 6)
+      ], 2)) : (o(), i("div", {
+        key: 1,
+        class: l(a(n).b("circle")),
+        style: c({ height: `${e.width}px`, width: `${e.width}px` })
+      }, [
+        (o(), i("svg", j, [
+          f("path", {
+            class: l(a(n).be("circle", "track")),
+            d: b.value,
+            stroke: `var(${a(n).cssVarName("fill-color-light")}, #e5e9f2)`,
+            "stroke-width": h.value,
+            fill: "none",
+            style: c(P.value)
+          }, null, 14, q),
+          f("path", {
+            class: l(a(n).be("circle", "path")),
+            d: b.value,
+            stroke: z.value,
+            fill: "none",
+            opacity: e.percentage ? 1 : 0,
+            "stroke-linecap": e.strokeLinecap,
+            "stroke-width": h.value,
+            style: c(N.value)
+          }, null, 14, G)
+        ]))
+      ], 6)),
+      (e.showText || t.$slots.default) && !e.textInside ? (o(), i("div", {
+        key: 2,
+        class: l(a(n).e("text")),
+        style: c({ fontSize: `${W.value}px` })
+      }, [
+        C(t.$slots, "default", { percentage: e.percentage }, () => [
+          e.status ? x.value?.icon ? (o(), A(a(O), L(M({ key: 1 }, x.value)), null, 16)) : y("", !0) : (o(), i("span", H, D(S.value), 1))
+        ])
+      ], 6)) : y("", !0)
+    ], 10, U));
+  }
+});
+export {
+  re as default
+};

package/es/components/qrcode/qrcode.vue2.js

@@ -0,0 +1,77 @@
+import { defineComponent as f, ref as w, onMounted as g, getCurrentInstance as v, watch as h, createElementBlock as p, openBlock as l, createBlock as C, resolveDynamicComponent as x, unref as c } from "vue";
+import { downloadByUrl as y } from "@vft/utils";
+import { toDataURL as E } from "qrcode";
+import { toCanvas as L } from "./toCanvas.js";
+const k = f({
+  name: "vft-qrcode"
+}), M = /* @__PURE__ */ f({
+  ...k,
+  props: {
+    value: {},
+    options: {},
+    width: { default: 200 },
+    logo: {},
+    tag: { default: "canvas" }
+  },
+  emits: ["done", "error"],
+  setup(t, { expose: s, emit: u }) {
+    const a = u, r = w(null);
+    async function i() {
+      try {
+        const o = String(t.value), e = c(r);
+        if (!e) return;
+        if (t.tag === "canvas") {
+          const n = await L({
+            canvas: e,
+            width: t.width,
+            logo: t.logo,
+            content: o,
+            options: t.options || {}
+          });
+          a("done", {
+            url: n,
+            ctx: e.getContext("2d")
+          });
+          return;
+        }
+        if (t.tag === "img") {
+          const n = await E(o, {
+            errorCorrectionLevel: "H",
+            width: t.width,
+            ...t.options
+          });
+          c(r).src = n, a("done", { url: n });
+        }
+      } catch (o) {
+        a("error", o);
+      }
+    }
+    function d(o) {
+      let e = "";
+      const n = c(r);
+      n instanceof HTMLCanvasElement ? e = n.toDataURL() : n instanceof HTMLImageElement && (e = n.src), e && y({
+        url: e,
+        fileName: o
+      });
+    }
+    g(i);
+    const m = v();
+    return h(
+      m.props,
+      () => {
+        i();
+      },
+      { deep: !0 }
+    ), s({
+      download: d
+    }), (o, e) => (l(), p("div", null, [
+      (l(), C(x(t.tag), {
+        ref_key: "wrapRef",
+        ref: r
+      }, null, 512))
+    ]));
+  }
+});
+export {
+  M as default
+};

package/es/components/radio/radio-button.vue2.js

@@ -0,0 +1,74 @@
+import { defineComponent as f, computed as C, createElementBlock as g, openBlock as N, normalizeClass as u, unref as e, withDirectives as V, createElementVNode as p, withModifiers as b, isRef as $, vModelRadio as R, normalizeStyle as w, renderSlot as x, createTextVNode as z, toDisplayString as D } from "vue";
+import "@vueuse/core";
+import "@vft/utils";
+import "../config-provider/hooks/use-global-config.js";
+import "lodash-es";
+import "../form/index.js";
+import { useNamespace as E } from "../../hooks/use-namespace/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import { useRadio as M } from "./use-radio.js";
+const F = ["value", "name", "disabled"], G = f({
+  name: "vft-radio-button"
+}), P = /* @__PURE__ */ f({
+  ...G,
+  props: {
+    size: {},
+    disabled: { type: Boolean },
+    label: { type: [String, Number, Boolean] },
+    value: { type: [String, Number, Boolean] },
+    modelValue: { type: [String, Number, Boolean] },
+    name: {},
+    border: { type: Boolean }
+  },
+  emits: ["click"],
+  setup(n, { emit: v }) {
+    const t = E("radio"), y = n, { radioRef: c, focus: a, size: k, disabled: d, modelValue: i, radioGroup: l, actualValue: s } = M(y), B = v, S = C(() => ({
+      backgroundColor: l?.fill || "",
+      borderColor: l?.fill || "",
+      boxShadow: l?.fill ? `-1px 0 0 0 ${l.fill}` : "",
+      color: l?.textColor || ""
+    }));
+    return (m, o) => (N(), g("label", {
+      class: u([
+        e(t).b("button"),
+        e(t).is("active", e(i) === e(s)),
+        e(t).is("disabled", e(d)),
+        e(t).is("focus", e(a)),
+        e(t).bm("button", e(k))
+      ])
+    }, [
+      V(p("input", {
+        ref_key: "radioRef",
+        ref: c,
+        "onUpdate:modelValue": o[0] || (o[0] = (r) => $(i) ? i.value = r : null),
+        class: u(e(t).be("button", "original-radio")),
+        value: e(s),
+        type: "radio",
+        name: n.name || e(l)?.name,
+        disabled: e(d),
+        onFocus: o[1] || (o[1] = (r) => a.value = !0),
+        onBlur: o[2] || (o[2] = (r) => a.value = !1),
+        onClick: o[3] || (o[3] = b(() => {
+        }, ["stop"]))
+      }, null, 42, F), [
+        [R, e(i)]
+      ]),
+      p("span", {
+        onClick: o[4] || (o[4] = (r) => B("click", m.$props)),
+        class: u(e(t).be("button", "inner")),
+        style: w(e(i) === e(s) ? S.value : {}),
+        onKeydown: o[5] || (o[5] = b(() => {
+        }, ["stop"]))
+      }, [
+        x(m.$slots, "default", {}, () => [
+          z(D(n.label), 1)
+        ])
+      ], 38)
+    ], 2));
+  }
+});
+export {
+  P as default
+};

package/es/components/radio/radio-group.vue2.js

@@ -0,0 +1,82 @@
+import { defineComponent as p, ref as E, onMounted as B, computed as k, provide as _, reactive as h, toRefs as C, watch as x, createElementBlock as u, openBlock as i, unref as a, normalizeClass as z, renderSlot as N, Fragment as A, renderList as F, createBlock as G, resolveDynamicComponent as L, nextTick as T } from "vue";
+import "../form/index.js";
+import { UPDATE_MODEL_EVENT as c, CHANGE_EVENT as V } from "../../constants/event.js";
+import "@vueuse/core";
+import "@vft/utils";
+import { debugWarn as D } from "../../utils/error.js";
+import "../config-provider/hooks/use-global-config.js";
+import "lodash-es";
+import { useId as R } from "../../hooks/use-id/index.js";
+import { useNamespace as S } from "../../hooks/use-namespace/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import { radioGroupKey as $ } from "./constants.js";
+import M from "./radio.vue2.js";
+import q from "./radio-button.vue2.js";
+import { useFormItem as w, useFormItemInputId as H } from "../form/hooks/use-form-item.js";
+const K = ["id", "aria-label", "aria-labelledby"], O = p({
+  name: "vft-radio-group"
+}), me = /* @__PURE__ */ p({
+  ...O,
+  props: {
+    id: {},
+    size: {},
+    disabled: { type: Boolean },
+    label: {},
+    modelValue: { type: [String, Number, Boolean] },
+    name: {},
+    fill: {},
+    textColor: {},
+    validateEvent: { type: Boolean, default: !0 },
+    useButton: { type: Boolean },
+    options: {}
+  },
+  emits: [c, V],
+  setup(r, { emit: f }) {
+    const t = r, m = f, b = S("radio"), v = R(), d = E(), { formItem: l } = w(), { inputId: y, isLabeledByFormItem: s } = H(t, {
+      formItemContext: l
+    }), I = (e) => {
+      m(c, e), T(() => m("change", e));
+    };
+    B(() => {
+      const e = d.value.querySelectorAll("[type=radio]"), n = e[0];
+      !Array.from(e).some((o) => o.checked) && n && (n.tabIndex = 0);
+    });
+    const g = k(() => t.name || v.value);
+    return _(
+      $,
+      h({
+        ...C(t),
+        changeEvent: I,
+        name: g
+      })
+    ), x(
+      () => t.modelValue,
+      () => {
+        t.validateEvent && l?.validate("change").catch((e) => D(e));
+      }
+    ), (e, n) => (i(), u("div", {
+      id: a(y),
+      ref_key: "radioGroupRef",
+      ref: d,
+      class: z(a(b).b("group")),
+      role: "radiogroup",
+      "aria-label": a(s) ? void 0 : r.label || "radio-group",
+      "aria-labelledby": a(s) ? a(l)?.labelId : void 0
+    }, [
+      r.options ? (i(!0), u(A, { key: 0 }, F(r.options, (o) => (i(), G(L(r.useButton ? q : M), {
+        size: o.size,
+        disabled: o.disabled,
+        label: o.label,
+        value: o.value,
+        name: o.name,
+        border: o.border,
+        key: o.value
+      }, null, 8, ["size", "disabled", "label", "value", "name", "border"]))), 128)) : N(e.$slots, "default", { key: 1 })
+    ], 10, K));
+  }
+});
+export {
+  me as default
+};

package/es/components/router-view-content/router-view-content.vue2.js

@@ -0,0 +1,61 @@
+import { defineComponent as p, computed as u, resolveComponent as C, createBlock as n, openBlock as a, withCtx as c, createVNode as f, unref as r, KeepAlive as x, createCommentVNode as A, resolveDynamicComponent as v, Transition as k, mergeProps as B } from "vue";
+import { getRouterKeyPath as N } from "@vft/router";
+import "vue-router";
+import { createReusableTemplate as R } from "@vueuse/core";
+const K = p({
+  name: "vft-router-view-content"
+}), b = /* @__PURE__ */ p({
+  ...K,
+  props: {
+    cacheList: {},
+    transitionName: {},
+    transitionAttr: {},
+    openKeepAlive: { type: Boolean, default: !0 },
+    isReloadFlag: { type: Boolean },
+    pageErrorStatus: { type: Boolean },
+    enableErrorHandle: { type: Boolean },
+    exceptionComp: {}
+  },
+  setup(e) {
+    const h = u(() => e.openKeepAlive ? e.cacheList : []), m = u(() => (t) => e.enableErrorHandle && e.pageErrorStatus && e.exceptionComp || t), y = u(() => (t) => {
+      let o = t.name;
+      return t.meta?.currentActivePath && (o = t.matched?.filter((l) => l.path === t.meta?.currentActivePath)?.[0].name), e.isReloadFlag ? void 0 : o;
+    }), [g, d] = R();
+    return (t, o) => {
+      const l = C("router-view");
+      return a(), n(l, null, {
+        default: c(({ Component: s, route: i }) => [
+          f(r(g), null, {
+            default: c(() => [
+              e.openKeepAlive ? (a(), n(x, {
+                key: 0,
+                include: h.value,
+                exclude: y.value(i)
+              }, [
+                e.isReloadFlag ? (a(), n(v(m.value(s)), {
+                  key: r(N)(i)
+                })) : A("", !0)
+              ], 1032, ["include", "exclude"])) : (a(), n(v(m.value(s)), {
+                key: i.fullPath
+              }))
+            ]),
+            _: 2
+          }, 1024),
+          e.transitionName ? (a(), n(k, B({
+            key: 0,
+            name: e.transitionName
+          }, e.transitionAttr), {
+            default: c(() => [
+              f(r(d))
+            ]),
+            _: 1
+          }, 16, ["name"])) : (a(), n(r(d), { key: 1 }))
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+export {
+  b as default
+};

package/es/components/roving-focus-group/roving-focus-item.vue2.js

@@ -0,0 +1,100 @@
+import { defineComponent as p, inject as l, ref as g, unref as r, nextTick as x, computed as d, provide as R, createBlock as G, openBlock as K, withCtx as V, renderSlot as S } from "vue";
+import { EVENT_CODE as U } from "../../constants/aria.js";
+import "@vueuse/core";
+import "@vft/utils";
+import { composeEventHandlers as a } from "../../utils/event.js";
+import "../config-provider/hooks/use-global-config.js";
+import "lodash-es";
+import "../form/index.js";
+import { useId as B } from "../../hooks/use-id/index.js";
+import "../../hooks/use-model-toggle/index.js";
+import "@popperjs/core";
+import "../../hooks/use-z-index/index.js";
+import { ROVING_FOCUS_GROUP_INJECTION_KEY as J, ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY as L } from "./tokens.js";
+import { VftCollectionItem as I, ROVING_FOCUS_COLLECTION_INJECTION_KEY as Y } from "./types.js";
+import { getFocusIntent as D, reorderArray as M, focusFirst as P } from "./utils.js";
+const j = p({
+  name: "VftRovingFocusItem",
+  components: {
+    "roving-focus-collection-item": I
+  }
+}), ie = /* @__PURE__ */ p({
+  ...j,
+  props: {
+    focusable: { type: Boolean, default: !0 },
+    active: { type: Boolean, default: !1 }
+  },
+  emits: ["mousedown", "focus", "keydown"],
+  setup(s, { emit: _ }) {
+    const v = s, c = _, { currentTabbedId: O, loop: C, onItemFocus: f, onItemShiftTab: E } = l(
+      J,
+      void 0
+    ), { getItems: b } = l(Y, void 0), n = B(), N = g(null), T = a(
+      (e) => {
+        c("mousedown", e);
+      },
+      (e) => {
+        v.focusable ? f(r(n)) : e.preventDefault();
+      }
+    ), F = a(
+      (e) => {
+        c("focus", e);
+      },
+      () => {
+        f(r(n));
+      }
+    ), h = a(
+      (e) => {
+        c("keydown", e);
+      },
+      (e) => {
+        const { key: m, shiftKey: w, target: y, currentTarget: u } = e;
+        if (m === U.tab && w) {
+          E();
+          return;
+        }
+        if (y !== u) return;
+        const i = D(e);
+        if (i) {
+          e.preventDefault();
+          let t = b().filter((o) => o.focusable).map((o) => o.ref);
+          switch (i) {
+            case "last": {
+              t.reverse();
+              break;
+            }
+            case "prev":
+            case "next": {
+              i === "prev" && t.reverse();
+              const o = t.indexOf(u);
+              t = C.value ? M(t, o + 1) : t.slice(o + 1);
+              break;
+            }
+          }
+          x(() => {
+            P(t);
+          });
+        }
+      }
+    ), k = d(() => O.value === r(n));
+    return R(L, {
+      rovingFocusGroupItemRef: N,
+      tabIndex: d(() => r(k) ? 0 : -1),
+      handleMousedown: T,
+      handleFocus: F,
+      handleKeydown: h
+    }), (e, m) => (K(), G(r(I), {
+      id: r(n),
+      focusable: s.focusable,
+      active: s.active
+    }, {
+      default: V(() => [
+        S(e.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["id", "focusable", "active"]));
+  }
+});
+export {
+  ie as default
+};