@revolugo/elements 6.9.3-beta.9 → 6.9.4-rc.0

package/dist/revolugo.vlist.BwlPoH0e.min.js

@@ -0,0 +1,1299 @@
+import { an as U, a9 as B, ap as K, a7 as fe, bw as p, a2 as E, k as P, a6 as Z, H as g, Y as me, c0 as et, af as k, aL as tt, b4 as ye, a1 as M, a as m, cn as nt, J as ge, K as at, a3 as _, O as lt, aK as Se, co as st, aH as it, D as Q, aM as he, a4 as x, F as re, t as oe, ac as rt, cp as be, a_ as pe, bY as ot, aZ as L, aa as ke, aV as ut, ck as ct } from "./revolugo.index.wc.DLkeXtka.min.js";
+import { a as ee, d as dt, c as vt, R as ft, t as mt, s as Ce, v as we, m as Ie, g as yt, h as ue } from "./revolugo.index.DZEISB0K.min.js";
+import { u as N, M as gt, e as G, m as D, A as St, n as Ve, D as ht, o as Ae, d as bt, b as pt } from "./revolugo.webcomponentwrapper.BNmjcBmh.min.js";
+import { u as kt } from "./revolugo.ssrboot.D7k4-YG4.min.js";
+import { c as Pe, u as Le, b as Oe, a as _e, m as Ee, d as Te } from "./revolugo.rounded.C-2ilaaW.min.js";
+import { V as ce } from "./revolugo.vicon.mrg8OisO.min.js";
+import { V as Ct } from "./revolugo.vdivider.D1ITKKuu.min.js";
+function Qe(e) {
+  try {
+    if (typeof document < "u") {
+      window.REVOLUGO_ELEMENTS_STYLES = window.REVOLUGO_ELEMENTS_STYLES || {
+        sheets: [],
+        components: []
+      };
+      const l = import.meta.url, a = l.slice(0, l.lastIndexOf("/") + 1) + e;
+      window.REVOLUGO_ELEMENTS_STYLES.sheets.push(a);
+      for (const n of REVOLUGO_ELEMENTS_STYLES.components)
+        n(a);
+      if (e.indexOf("fonts") >= 0) {
+        const n = document.createElement("link");
+        n.rel = "stylesheet", linK.href = a, document.head.appendChild(n);
+      }
+    }
+  } catch (l) {
+    console.error("[revolugo-elements] ", l);
+  }
+}
+const te = Symbol.for("vuetify:list");
+function Be() {
+  const e = U(te, {
+    hasPrepend: B(!1),
+    updateHasPrepend: () => null
+  }), l = {
+    hasPrepend: B(!1),
+    updateHasPrepend: (a) => {
+      a && (l.hasPrepend.value = a);
+    }
+  };
+  return K(te, l), e;
+}
+function Me() {
+  return U(te, null);
+}
+const ae = (e) => {
+  const l = {
+    activate: (a) => {
+      let {
+        id: n,
+        value: s,
+        activated: t
+      } = a;
+      return n = p(n), e && !s && t.size === 1 && t.has(n) || (s ? t.add(n) : t.delete(n)), t;
+    },
+    in: (a, n, s) => {
+      let t = /* @__PURE__ */ new Set();
+      if (a != null)
+        for (const i of fe(a))
+          t = l.activate({
+            id: i,
+            value: !0,
+            activated: new Set(t),
+            children: n,
+            parents: s
+          });
+      return t;
+    },
+    out: (a) => Array.from(a)
+  };
+  return l;
+}, je = (e) => {
+  const l = ae(e);
+  return {
+    activate: (n) => {
+      let {
+        activated: s,
+        id: t,
+        ...i
+      } = n;
+      t = p(t);
+      const o = s.has(t) ? /* @__PURE__ */ new Set([t]) : /* @__PURE__ */ new Set();
+      return l.activate({
+        ...i,
+        id: t,
+        activated: o
+      });
+    },
+    in: (n, s, t) => {
+      let i = /* @__PURE__ */ new Set();
+      if (n != null) {
+        const o = fe(n);
+        o.length && (i = l.in(o.slice(0, 1), s, t));
+      }
+      return i;
+    },
+    out: (n, s, t) => l.out(n, s, t)
+  };
+}, wt = (e) => {
+  const l = ae(e);
+  return {
+    activate: (n) => {
+      let {
+        id: s,
+        activated: t,
+        children: i,
+        ...o
+      } = n;
+      return s = p(s), i.has(s) ? t : l.activate({
+        id: s,
+        activated: t,
+        children: i,
+        ...o
+      });
+    },
+    in: l.in,
+    out: l.out
+  };
+}, It = (e) => {
+  const l = je(e);
+  return {
+    activate: (n) => {
+      let {
+        id: s,
+        activated: t,
+        children: i,
+        ...o
+      } = n;
+      return s = p(s), i.has(s) ? t : l.activate({
+        id: s,
+        activated: t,
+        children: i,
+        ...o
+      });
+    },
+    in: l.in,
+    out: l.out
+  };
+}, Vt = {
+  open: (e) => {
+    let {
+      id: l,
+      value: a,
+      opened: n,
+      parents: s
+    } = e;
+    if (a) {
+      const t = /* @__PURE__ */ new Set();
+      t.add(l);
+      let i = s.get(l);
+      for (; i != null; )
+        t.add(i), i = s.get(i);
+      return t;
+    } else
+      return n.delete(l), n;
+  },
+  select: () => null
+}, xe = {
+  open: (e) => {
+    let {
+      id: l,
+      value: a,
+      opened: n,
+      parents: s
+    } = e;
+    if (a) {
+      let t = s.get(l);
+      for (n.add(l); t != null && t !== l; )
+        n.add(t), t = s.get(t);
+      return n;
+    } else
+      n.delete(l);
+    return n;
+  },
+  select: () => null
+}, At = {
+  open: xe.open,
+  select: (e) => {
+    let {
+      id: l,
+      value: a,
+      opened: n,
+      parents: s
+    } = e;
+    if (!a) return n;
+    const t = [];
+    let i = s.get(l);
+    for (; i != null; )
+      t.push(i), i = s.get(i);
+    return new Set(t);
+  }
+}, le = (e) => {
+  const l = {
+    select: (a) => {
+      let {
+        id: n,
+        value: s,
+        selected: t
+      } = a;
+      if (n = p(n), e && !s) {
+        const i = Array.from(t.entries()).reduce((o, d) => {
+          let [y, c] = d;
+          return c === "on" && o.push(y), o;
+        }, []);
+        if (i.length === 1 && i[0] === n) return t;
+      }
+      return t.set(n, s ? "on" : "off"), t;
+    },
+    in: (a, n, s) => {
+      const t = /* @__PURE__ */ new Map();
+      for (const i of a || [])
+        l.select({
+          id: i,
+          value: !0,
+          selected: t,
+          children: n,
+          parents: s
+        });
+      return t;
+    },
+    out: (a) => {
+      const n = [];
+      for (const [s, t] of a.entries())
+        t === "on" && n.push(s);
+      return n;
+    }
+  };
+  return l;
+}, Fe = (e) => {
+  const l = le(e);
+  return {
+    select: (n) => {
+      let {
+        selected: s,
+        id: t,
+        ...i
+      } = n;
+      t = p(t);
+      const o = s.has(t) ? /* @__PURE__ */ new Map([[t, s.get(t)]]) : /* @__PURE__ */ new Map();
+      return l.select({
+        ...i,
+        id: t,
+        selected: o
+      });
+    },
+    in: (n, s, t) => n?.length ? l.in(n.slice(0, 1), s, t) : /* @__PURE__ */ new Map(),
+    out: (n, s, t) => l.out(n, s, t)
+  };
+}, Pt = (e) => {
+  const l = le(e);
+  return {
+    select: (n) => {
+      let {
+        id: s,
+        selected: t,
+        children: i,
+        ...o
+      } = n;
+      return s = p(s), i.has(s) ? t : l.select({
+        id: s,
+        selected: t,
+        children: i,
+        ...o
+      });
+    },
+    in: l.in,
+    out: l.out
+  };
+}, Lt = (e) => {
+  const l = Fe(e);
+  return {
+    select: (n) => {
+      let {
+        id: s,
+        selected: t,
+        children: i,
+        ...o
+      } = n;
+      return s = p(s), i.has(s) ? t : l.select({
+        id: s,
+        selected: t,
+        children: i,
+        ...o
+      });
+    },
+    in: l.in,
+    out: l.out
+  };
+}, Ot = (e) => {
+  const l = {
+    select: (a) => {
+      let {
+        id: n,
+        value: s,
+        selected: t,
+        children: i,
+        parents: o
+      } = a;
+      n = p(n);
+      const d = new Map(t), y = [n];
+      for (; y.length; ) {
+        const v = y.shift();
+        t.set(p(v), s ? "on" : "off"), i.has(v) && y.push(...i.get(v));
+      }
+      let c = p(o.get(n));
+      for (; c; ) {
+        const v = i.get(c), h = v.every((r) => t.get(p(r)) === "on"), b = v.every((r) => !t.has(p(r)) || t.get(p(r)) === "off");
+        t.set(c, h ? "on" : b ? "off" : "indeterminate"), c = p(o.get(c));
+      }
+      return e && !s && Array.from(t.entries()).reduce((h, b) => {
+        let [r, u] = b;
+        return u === "on" && h.push(r), h;
+      }, []).length === 0 ? d : t;
+    },
+    in: (a, n, s) => {
+      let t = /* @__PURE__ */ new Map();
+      for (const i of a || [])
+        t = l.select({
+          id: i,
+          value: !0,
+          selected: t,
+          children: n,
+          parents: s
+        });
+      return t;
+    },
+    out: (a, n) => {
+      const s = [];
+      for (const [t, i] of a.entries())
+        i === "on" && !n.has(t) && s.push(t);
+      return s;
+    }
+  };
+  return l;
+}, F = Symbol.for("vuetify:nested"), Ne = {
+  id: B(),
+  root: {
+    register: () => null,
+    unregister: () => null,
+    parents: P(/* @__PURE__ */ new Map()),
+    children: P(/* @__PURE__ */ new Map()),
+    open: () => null,
+    openOnSelect: () => null,
+    activate: () => null,
+    select: () => null,
+    activatable: P(!1),
+    selectable: P(!1),
+    opened: P(/* @__PURE__ */ new Set()),
+    activated: P(/* @__PURE__ */ new Set()),
+    selected: P(/* @__PURE__ */ new Map()),
+    selectedValues: P([]),
+    getPath: () => []
+  }
+}, _t = E({
+  activatable: Boolean,
+  selectable: Boolean,
+  activeStrategy: [String, Function, Object],
+  selectStrategy: [String, Function, Object],
+  openStrategy: [String, Object],
+  opened: null,
+  activated: null,
+  selected: null,
+  mandatory: Boolean
+}, "nested"), Et = (e) => {
+  let l = !1;
+  const a = P(/* @__PURE__ */ new Map()), n = P(/* @__PURE__ */ new Map()), s = Z(e, "opened", e.opened, (r) => new Set(r), (r) => [...r.values()]), t = g(() => {
+    if (typeof e.activeStrategy == "object") return e.activeStrategy;
+    if (typeof e.activeStrategy == "function") return e.activeStrategy(e.mandatory);
+    switch (e.activeStrategy) {
+      case "leaf":
+        return wt(e.mandatory);
+      case "single-leaf":
+        return It(e.mandatory);
+      case "independent":
+        return ae(e.mandatory);
+      case "single-independent":
+      default:
+        return je(e.mandatory);
+    }
+  }), i = g(() => {
+    if (typeof e.selectStrategy == "object") return e.selectStrategy;
+    if (typeof e.selectStrategy == "function") return e.selectStrategy(e.mandatory);
+    switch (e.selectStrategy) {
+      case "single-leaf":
+        return Lt(e.mandatory);
+      case "leaf":
+        return Pt(e.mandatory);
+      case "independent":
+        return le(e.mandatory);
+      case "single-independent":
+        return Fe(e.mandatory);
+      case "classic":
+      default:
+        return Ot(e.mandatory);
+    }
+  }), o = g(() => {
+    if (typeof e.openStrategy == "object") return e.openStrategy;
+    switch (e.openStrategy) {
+      case "list":
+        return At;
+      case "single":
+        return Vt;
+      case "multiple":
+      default:
+        return xe;
+    }
+  }), d = Z(e, "activated", e.activated, (r) => t.value.in(r, a.value, n.value), (r) => t.value.out(r, a.value, n.value)), y = Z(e, "selected", e.selected, (r) => i.value.in(r, a.value, n.value), (r) => i.value.out(r, a.value, n.value));
+  me(() => {
+    l = !0;
+  });
+  function c(r) {
+    const u = [];
+    let f = r;
+    for (; f != null; )
+      u.unshift(f), f = n.value.get(f);
+    return u;
+  }
+  const v = et("nested"), h = /* @__PURE__ */ new Set(), b = {
+    id: B(),
+    root: {
+      opened: s,
+      activatable: k(e, "activatable"),
+      selectable: k(e, "selectable"),
+      activated: d,
+      selected: y,
+      selectedValues: g(() => {
+        const r = [];
+        for (const [u, f] of y.value.entries())
+          f === "on" && r.push(u);
+        return r;
+      }),
+      register: (r, u, f) => {
+        if (h.has(r)) {
+          c(r).map(String).join(" -> "), c(u).concat(r).map(String).join(" -> ");
+          return;
+        } else
+          h.add(r);
+        u && r !== u && n.value.set(r, u), f && a.value.set(r, []), u != null && a.value.set(u, [...a.value.get(u) || [], r]);
+      },
+      unregister: (r) => {
+        if (l) return;
+        h.delete(r), a.value.delete(r);
+        const u = n.value.get(r);
+        if (u) {
+          const f = a.value.get(u) ?? [];
+          a.value.set(u, f.filter((S) => S !== r));
+        }
+        n.value.delete(r);
+      },
+      open: (r, u, f) => {
+        v.emit("click:open", {
+          id: r,
+          value: u,
+          path: c(r),
+          event: f
+        });
+        const S = o.value.open({
+          id: r,
+          value: u,
+          opened: new Set(s.value),
+          children: a.value,
+          parents: n.value,
+          event: f
+        });
+        S && (s.value = S);
+      },
+      openOnSelect: (r, u, f) => {
+        const S = o.value.select({
+          id: r,
+          value: u,
+          selected: new Map(y.value),
+          opened: new Set(s.value),
+          children: a.value,
+          parents: n.value,
+          event: f
+        });
+        S && (s.value = S);
+      },
+      select: (r, u, f) => {
+        v.emit("click:select", {
+          id: r,
+          value: u,
+          path: c(r),
+          event: f
+        });
+        const S = i.value.select({
+          id: r,
+          value: u,
+          selected: new Map(y.value),
+          children: a.value,
+          parents: n.value,
+          event: f
+        });
+        S && (y.value = S), b.root.openOnSelect(r, u, f);
+      },
+      activate: (r, u, f) => {
+        if (!e.activatable)
+          return b.root.select(r, !0, f);
+        v.emit("click:activate", {
+          id: r,
+          value: u,
+          path: c(r),
+          event: f
+        });
+        const S = t.value.activate({
+          id: r,
+          value: u,
+          activated: new Set(d.value),
+          children: a.value,
+          parents: n.value,
+          event: f
+        });
+        if (S.size !== d.value.size)
+          d.value = S;
+        else {
+          for (const I of S)
+            if (!d.value.has(I)) {
+              d.value = S;
+              return;
+            }
+          for (const I of d.value)
+            if (!S.has(I)) {
+              d.value = S;
+              return;
+            }
+        }
+      },
+      children: a,
+      parents: n,
+      getPath: c
+    }
+  };
+  return K(F, b), b.root;
+}, Ge = (e, l) => {
+  const a = U(F, Ne), n = Symbol(tt()), s = g(() => e.value !== void 0 ? e.value : n), t = {
+    ...a,
+    id: s,
+    open: (i, o) => a.root.open(s.value, i, o),
+    openOnSelect: (i, o) => a.root.openOnSelect(s.value, i, o),
+    isOpen: g(() => a.root.opened.value.has(s.value)),
+    parent: g(() => a.root.parents.value.get(s.value)),
+    activate: (i, o) => a.root.activate(s.value, i, o),
+    isActivated: g(() => a.root.activated.value.has(p(s.value))),
+    select: (i, o) => a.root.select(s.value, i, o),
+    isSelected: g(() => a.root.selected.value.get(p(s.value)) === "on"),
+    isIndeterminate: g(() => a.root.selected.value.get(p(s.value)) === "indeterminate"),
+    isLeaf: g(() => !a.root.children.value.get(s.value)),
+    isGroupActivator: a.isGroupActivator
+  };
+  return ye(() => {
+    !a.isGroupActivator && a.root.register(s.value, a.id.value, l);
+  }), me(() => {
+    !a.isGroupActivator && a.root.unregister(s.value);
+  }), l && K(F, t), t;
+}, Tt = () => {
+  const e = U(F, Ne);
+  K(F, {
+    ...e,
+    isGroupActivator: !0
+  });
+}, Bt = nt({
+  name: "VListGroupActivator",
+  setup(e, l) {
+    let {
+      slots: a
+    } = l;
+    return Tt(), () => a.default?.();
+  }
+}), Mt = E({
+  /* @deprecated */
+  activeColor: String,
+  baseColor: String,
+  color: String,
+  collapseIcon: {
+    type: _,
+    default: "$collapse"
+  },
+  expandIcon: {
+    type: _,
+    default: "$expand"
+  },
+  prependIcon: _,
+  appendIcon: _,
+  fluid: Boolean,
+  subgroup: Boolean,
+  title: String,
+  value: null,
+  ...D(),
+  ...G()
+}, "VListGroup"), de = M()({
+  name: "VListGroup",
+  props: Mt(),
+  setup(e, l) {
+    let {
+      slots: a
+    } = l;
+    const {
+      isOpen: n,
+      open: s,
+      id: t
+    } = Ge(k(e, "value"), !0), i = g(() => `v-list-group--id-${String(t.value)}`), o = Me(), {
+      isBooted: d
+    } = kt();
+    function y(b) {
+      b.stopPropagation(), s(!n.value, b);
+    }
+    const c = g(() => ({
+      onClick: y,
+      class: "v-list-group__header",
+      id: i.value
+    })), v = g(() => n.value ? e.collapseIcon : e.expandIcon), h = g(() => ({
+      VListItem: {
+        active: n.value,
+        activeColor: e.activeColor,
+        baseColor: e.baseColor,
+        color: e.color,
+        prependIcon: e.prependIcon || e.subgroup && v.value,
+        appendIcon: e.appendIcon || !e.subgroup && v.value,
+        title: e.title,
+        value: e.value
+      }
+    }));
+    return N(() => m(e.tag, {
+      class: ["v-list-group", {
+        "v-list-group--prepend": o?.hasPrepend.value,
+        "v-list-group--fluid": e.fluid,
+        "v-list-group--subgroup": e.subgroup,
+        "v-list-group--open": n.value
+      }, e.class],
+      style: e.style
+    }, {
+      default: () => [a.activator && m(ee, {
+        defaults: h.value
+      }, {
+        default: () => [m(Bt, null, {
+          default: () => [a.activator({
+            props: c.value,
+            isOpen: n.value
+          })]
+        })]
+      }), m(gt, {
+        transition: {
+          component: dt
+        },
+        disabled: !d.value
+      }, {
+        default: () => [ge(m("div", {
+          class: "v-list-group__items",
+          role: "group",
+          "aria-labelledby": i.value
+        }, [a.default?.()]), [[at, n.value]])]
+      })]
+    })), {
+      isOpen: n
+    };
+  }
+}), jt = E({
+  opacity: [Number, String],
+  ...D(),
+  ...G()
+}, "VListItemSubtitle"), xt = M()({
+  name: "VListItemSubtitle",
+  props: jt(),
+  setup(e, l) {
+    let {
+      slots: a
+    } = l;
+    return N(() => m(e.tag, {
+      class: ["v-list-item-subtitle", e.class],
+      style: [{
+        "--v-list-item-subtitle-opacity": e.opacity
+      }, e.style]
+    }, a)), {};
+  }
+}), Ft = vt("v-list-item-title"), Nt = E({
+  active: {
+    type: Boolean,
+    default: void 0
+  },
+  activeClass: String,
+  /* @deprecated */
+  activeColor: String,
+  appendAvatar: String,
+  appendIcon: _,
+  baseColor: String,
+  disabled: Boolean,
+  lines: [Boolean, String],
+  link: {
+    type: Boolean,
+    default: void 0
+  },
+  nav: Boolean,
+  prependAvatar: String,
+  prependIcon: _,
+  ripple: {
+    type: [Boolean, Object],
+    default: !0
+  },
+  slim: Boolean,
+  subtitle: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  title: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  value: null,
+  onClick: x(),
+  onClickOnce: x(),
+  ...Te(),
+  ...D(),
+  ...Ie(),
+  ...Ae(),
+  ...Ee(),
+  ..._e(),
+  ...ht(),
+  ...G(),
+  ...he(),
+  ...we({
+    variant: "text"
+  })
+}, "VListItem"), ve = M()({
+  name: "VListItem",
+  directives: {
+    Ripple: ft
+  },
+  props: Nt(),
+  emits: {
+    click: (e) => !0
+  },
+  setup(e, l) {
+    let {
+      attrs: a,
+      slots: n,
+      emit: s
+    } = l;
+    const t = St(e, a), i = g(() => e.value === void 0 ? t.href.value : e.value), {
+      activate: o,
+      isActivated: d,
+      select: y,
+      isOpen: c,
+      isSelected: v,
+      isIndeterminate: h,
+      isGroupActivator: b,
+      root: r,
+      parent: u,
+      openOnSelect: f,
+      id: S
+    } = Ge(i, !1), I = Me(), V = g(() => e.active !== !1 && (e.active || t.isActive?.value || (r.activatable.value ? d.value : v.value))), j = g(() => e.link !== !1 && t.isLink.value), T = g(() => !!I && (r.selectable.value || r.activatable.value || e.value != null)), A = g(() => !e.disabled && e.link !== !1 && (e.link || t.isClickable.value || T.value)), $ = g(() => e.rounded || e.nav), Y = g(() => e.color ?? e.activeColor), H = g(() => ({
+      color: V.value ? Y.value ?? e.baseColor : e.baseColor,
+      variant: e.variant
+    }));
+    lt(() => t.isActive?.value, (w) => {
+      w && R();
+    }), ye(() => {
+      t.isActive?.value && R();
+    });
+    function R() {
+      u.value != null && r.open(u.value, !0), f(!0);
+    }
+    const {
+      themeClasses: z
+    } = Se(e), {
+      borderClasses: O
+    } = Pe(e), {
+      colorClasses: C,
+      colorStyles: q,
+      variantClasses: Ke
+    } = mt(H), {
+      densityClasses: $e
+    } = Ce(e), {
+      dimensionStyles: Ye
+    } = Ve(e), {
+      elevationClasses: He
+    } = Le(e), {
+      roundedClasses: ze
+    } = Oe($), qe = g(() => e.lines ? `v-list-item--${e.lines}-line` : void 0), X = g(() => ({
+      isActive: V.value,
+      select: y,
+      isOpen: c.value,
+      isSelected: v.value,
+      isIndeterminate: h.value
+    }));
+    function Xe(w) {
+      s("click", w), A.value && (t.navigate?.(w), !b && (r.activatable.value ? o(!d.value, w) : (r.selectable.value || e.value != null) && y(!v.value, w)));
+    }
+    function Je(w) {
+      const J = w.target;
+      ["INPUT", "TEXTAREA"].includes(J.tagName) || (w.key === "Enter" || w.key === " ") && (w.preventDefault(), w.target.dispatchEvent(new MouseEvent("click", w)));
+    }
+    return N(() => {
+      const w = j.value ? "a" : e.tag, J = n.title || e.title != null, We = n.subtitle || e.subtitle != null, se = !!(e.appendAvatar || e.appendIcon), Ze = !!(se || n.append), ie = !!(e.prependAvatar || e.prependIcon), W = !!(ie || n.prepend);
+      return I?.updateHasPrepend(W), e.activeColor && st("active-color", ["color", "base-color"]), ge(m(w, Q({
+        class: ["v-list-item", {
+          "v-list-item--active": V.value,
+          "v-list-item--disabled": e.disabled,
+          "v-list-item--link": A.value,
+          "v-list-item--nav": e.nav,
+          "v-list-item--prepend": !W && I?.hasPrepend.value,
+          "v-list-item--slim": e.slim,
+          [`${e.activeClass}`]: e.activeClass && V.value
+        }, z.value, O.value, C.value, $e.value, He.value, qe.value, ze.value, Ke.value, e.class],
+        style: [q.value, Ye.value, e.style],
+        tabindex: A.value ? I ? -2 : 0 : void 0,
+        "aria-selected": T.value ? r.activatable.value ? d.value : r.selectable.value ? v.value : V.value : void 0,
+        onClick: Xe,
+        onKeydown: A.value && !j.value && Je
+      }, t.linkProps), {
+        default: () => [yt(A.value || V.value, "v-list-item"), W && m("div", {
+          key: "prepend",
+          class: "v-list-item__prepend"
+        }, [n.prepend ? m(ee, {
+          key: "prepend-defaults",
+          disabled: !ie,
+          defaults: {
+            VAvatar: {
+              density: e.density,
+              image: e.prependAvatar
+            },
+            VIcon: {
+              density: e.density,
+              icon: e.prependIcon
+            },
+            VListItemAction: {
+              start: !0
+            }
+          }
+        }, {
+          default: () => [n.prepend?.(X.value)]
+        }) : m(re, null, [e.prependAvatar && m(ue, {
+          key: "prepend-avatar",
+          density: e.density,
+          image: e.prependAvatar
+        }, null), e.prependIcon && m(ce, {
+          key: "prepend-icon",
+          density: e.density,
+          icon: e.prependIcon
+        }, null)]), m("div", {
+          class: "v-list-item__spacer"
+        }, null)]), m("div", {
+          class: "v-list-item__content",
+          "data-no-activator": ""
+        }, [J && m(Ft, {
+          key: "title"
+        }, {
+          default: () => [n.title?.({
+            title: e.title
+          }) ?? oe(e.title)]
+        }), We && m(xt, {
+          key: "subtitle"
+        }, {
+          default: () => [n.subtitle?.({
+            subtitle: e.subtitle
+          }) ?? oe(e.subtitle)]
+        }), n.default?.(X.value)]), Ze && m("div", {
+          key: "append",
+          class: "v-list-item__append"
+        }, [n.append ? m(ee, {
+          key: "append-defaults",
+          disabled: !se,
+          defaults: {
+            VAvatar: {
+              density: e.density,
+              image: e.appendAvatar
+            },
+            VIcon: {
+              density: e.density,
+              icon: e.appendIcon
+            },
+            VListItemAction: {
+              end: !0
+            }
+          }
+        }, {
+          default: () => [n.append?.(X.value)]
+        }) : m(re, null, [e.appendIcon && m(ce, {
+          key: "append-icon",
+          density: e.density,
+          icon: e.appendIcon
+        }, null), e.appendAvatar && m(ue, {
+          key: "append-avatar",
+          density: e.density,
+          image: e.appendAvatar
+        }, null)]), m("div", {
+          class: "v-list-item__spacer"
+        }, null)])]
+      }), [[it("ripple"), A.value && e.ripple]]);
+    }), {
+      activate: o,
+      isActivated: d,
+      isGroupActivator: b,
+      isSelected: v,
+      list: I,
+      select: y,
+      root: r,
+      id: S,
+      link: t
+    };
+  }
+}), Gt = E({
+  color: String,
+  inset: Boolean,
+  sticky: Boolean,
+  title: String,
+  ...D(),
+  ...G()
+}, "VListSubheader"), Dt = M()({
+  name: "VListSubheader",
+  props: Gt(),
+  setup(e, l) {
+    let {
+      slots: a
+    } = l;
+    const {
+      textColorClasses: n,
+      textColorStyles: s
+    } = bt(k(e, "color"));
+    return N(() => {
+      const t = !!(a.default || e.title);
+      return m(e.tag, {
+        class: ["v-list-subheader", {
+          "v-list-subheader--inset": e.inset,
+          "v-list-subheader--sticky": e.sticky
+        }, n.value, e.class],
+        style: [{
+          textColorStyles: s
+        }, e.style]
+      }, {
+        default: () => [t && m("div", {
+          class: "v-list-subheader__text"
+        }, [a.default?.() ?? e.title])]
+      });
+    }), {};
+  }
+}), Rt = E({
+  items: Array,
+  returnObject: Boolean
+}, "VListChildren"), De = M()({
+  name: "VListChildren",
+  props: Rt(),
+  setup(e, l) {
+    let {
+      slots: a
+    } = l;
+    return Be(), () => a.default?.() ?? e.items?.map((n) => {
+      let {
+        children: s,
+        props: t,
+        type: i,
+        raw: o
+      } = n;
+      if (i === "divider")
+        return a.divider?.({
+          props: t
+        }) ?? m(Ct, t, null);
+      if (i === "subheader")
+        return a.subheader?.({
+          props: t
+        }) ?? m(Dt, t, null);
+      const d = {
+        subtitle: a.subtitle ? (c) => a.subtitle?.({
+          ...c,
+          item: o
+        }) : void 0,
+        prepend: a.prepend ? (c) => a.prepend?.({
+          ...c,
+          item: o
+        }) : void 0,
+        append: a.append ? (c) => a.append?.({
+          ...c,
+          item: o
+        }) : void 0,
+        title: a.title ? (c) => a.title?.({
+          ...c,
+          item: o
+        }) : void 0
+      }, y = de.filterProps(t);
+      return s ? m(de, Q({
+        value: t?.value
+      }, y), {
+        activator: (c) => {
+          let {
+            props: v
+          } = c;
+          const h = {
+            ...t,
+            ...v,
+            value: e.returnObject ? o : t.value
+          };
+          return a.header ? a.header({
+            props: h
+          }) : m(ve, h, d);
+        },
+        default: () => m(De, {
+          items: s,
+          returnObject: e.returnObject
+        }, a)
+      }) : a.item ? a.item({
+        props: t
+      }) : m(ve, Q(t, {
+        value: e.returnObject ? o : t.value
+      }), d);
+    });
+  }
+}), Ut = E({
+  items: {
+    type: Array,
+    default: () => []
+  },
+  itemTitle: {
+    type: [String, Array, Function],
+    default: "title"
+  },
+  itemValue: {
+    type: [String, Array, Function],
+    default: "value"
+  },
+  itemChildren: {
+    type: [Boolean, String, Array, Function],
+    default: "children"
+  },
+  itemProps: {
+    type: [Boolean, String, Array, Function],
+    default: "props"
+  },
+  returnObject: Boolean,
+  valueComparator: Function
+}, "list-items");
+function ne(e, l) {
+  const a = L(l, e.itemTitle, l), n = L(l, e.itemValue, a), s = L(l, e.itemChildren), t = e.itemProps === !0 ? typeof l == "object" && l != null && !Array.isArray(l) ? "children" in l ? ke(l, ["children"]) : l : void 0 : L(l, e.itemProps), i = {
+    title: a,
+    value: n,
+    ...t
+  };
+  return {
+    title: String(i.title ?? ""),
+    value: i.value,
+    props: i,
+    children: Array.isArray(s) ? Re(e, s) : void 0,
+    raw: l
+  };
+}
+function Re(e, l) {
+  const a = pe(e, ["itemTitle", "itemValue", "itemChildren", "itemProps", "returnObject", "valueComparator"]), n = [];
+  for (const s of l)
+    n.push(ne(a, s));
+  return n;
+}
+function Qt(e) {
+  const l = g(() => Re(e, e.items)), a = g(() => l.value.some((o) => o.value === null)), n = B(/* @__PURE__ */ new Map()), s = B([]);
+  rt(() => {
+    const o = l.value, d = /* @__PURE__ */ new Map(), y = [];
+    for (let c = 0; c < o.length; c++) {
+      const v = o[c];
+      if (be(v.value) || v.value === null) {
+        let h = d.get(v.value);
+        h || (h = [], d.set(v.value, h)), h.push(v);
+      } else
+        y.push(v);
+    }
+    n.value = d, s.value = y;
+  });
+  function t(o) {
+    const d = n.value, y = l.value, c = s.value, v = a.value, h = e.returnObject, b = !!e.valueComparator, r = e.valueComparator || ot, u = pe(e, ["itemTitle", "itemValue", "itemChildren", "itemProps", "returnObject", "valueComparator"]), f = [];
+    e: for (const S of o) {
+      if (!v && S === null) continue;
+      if (h && typeof S == "string") {
+        f.push(ne(u, S));
+        continue;
+      }
+      const I = d.get(S);
+      if (b || !I) {
+        for (const V of b ? y : c)
+          if (r(S, V.value)) {
+            f.push(V);
+            continue e;
+          }
+        f.push(ne(u, S));
+        continue;
+      }
+      f.push(...I);
+    }
+    return f;
+  }
+  function i(o) {
+    return e.returnObject ? o.map((d) => {
+      let {
+        raw: y
+      } = d;
+      return y;
+    }) : o.map((d) => {
+      let {
+        value: y
+      } = d;
+      return y;
+    });
+  }
+  return {
+    items: l,
+    transformIn: t,
+    transformOut: i
+  };
+}
+function Kt(e, l) {
+  const a = L(l, e.itemType, "item"), n = be(l) ? l : L(l, e.itemTitle), s = L(l, e.itemValue, void 0), t = L(l, e.itemChildren), i = e.itemProps === !0 ? ke(l, ["children"]) : L(l, e.itemProps), o = {
+    title: n,
+    value: s,
+    ...i
+  };
+  return {
+    type: a,
+    title: o.title,
+    value: o.value,
+    props: o,
+    children: a === "item" && t ? Ue(e, t) : void 0,
+    raw: l
+  };
+}
+function Ue(e, l) {
+  const a = [];
+  for (const n of l)
+    a.push(Kt(e, n));
+  return a;
+}
+function $t(e) {
+  return {
+    items: g(() => Ue(e, e.items))
+  };
+}
+const Yt = E({
+  baseColor: String,
+  /* @deprecated */
+  activeColor: String,
+  activeClass: String,
+  bgColor: String,
+  disabled: Boolean,
+  expandIcon: _,
+  collapseIcon: _,
+  lines: {
+    type: [Boolean, String],
+    default: "one"
+  },
+  slim: Boolean,
+  nav: Boolean,
+  "onClick:open": x(),
+  "onClick:select": x(),
+  "onUpdate:opened": x(),
+  ..._t({
+    selectStrategy: "single-leaf",
+    openStrategy: "list"
+  }),
+  ...Te(),
+  ...D(),
+  ...Ie(),
+  ...Ae(),
+  ...Ee(),
+  itemType: {
+    type: String,
+    default: "type"
+  },
+  ...Ut(),
+  ..._e(),
+  ...G(),
+  ...he(),
+  ...we({
+    variant: "text"
+  })
+}, "VList"), en = M()({
+  name: "VList",
+  props: Yt(),
+  emits: {
+    "update:selected": (e) => !0,
+    "update:activated": (e) => !0,
+    "update:opened": (e) => !0,
+    "click:open": (e) => !0,
+    "click:activate": (e) => !0,
+    "click:select": (e) => !0
+  },
+  setup(e, l) {
+    let {
+      slots: a
+    } = l;
+    const {
+      items: n
+    } = $t(e), {
+      themeClasses: s
+    } = Se(e), {
+      backgroundColorClasses: t,
+      backgroundColorStyles: i
+    } = pt(k(e, "bgColor")), {
+      borderClasses: o
+    } = Pe(e), {
+      densityClasses: d
+    } = Ce(e), {
+      dimensionStyles: y
+    } = Ve(e), {
+      elevationClasses: c
+    } = Le(e), {
+      roundedClasses: v
+    } = Oe(e), {
+      children: h,
+      open: b,
+      parents: r,
+      select: u,
+      getPath: f
+    } = Et(e), S = g(() => e.lines ? `v-list--${e.lines}-line` : void 0), I = k(e, "activeColor"), V = k(e, "baseColor"), j = k(e, "color");
+    Be(), ut({
+      VListGroup: {
+        activeColor: I,
+        baseColor: V,
+        color: j,
+        expandIcon: k(e, "expandIcon"),
+        collapseIcon: k(e, "collapseIcon")
+      },
+      VListItem: {
+        activeClass: k(e, "activeClass"),
+        activeColor: I,
+        baseColor: V,
+        color: j,
+        density: k(e, "density"),
+        disabled: k(e, "disabled"),
+        lines: k(e, "lines"),
+        nav: k(e, "nav"),
+        slim: k(e, "slim"),
+        variant: k(e, "variant")
+      }
+    });
+    const T = B(!1), A = P();
+    function $(C) {
+      T.value = !0;
+    }
+    function Y(C) {
+      T.value = !1;
+    }
+    function H(C) {
+      !T.value && !(C.relatedTarget && A.value?.contains(C.relatedTarget)) && O();
+    }
+    function R(C) {
+      const q = C.target;
+      if (!(!A.value || ["INPUT", "TEXTAREA"].includes(q.tagName))) {
+        if (C.key === "ArrowDown")
+          O("next");
+        else if (C.key === "ArrowUp")
+          O("prev");
+        else if (C.key === "Home")
+          O("first");
+        else if (C.key === "End")
+          O("last");
+        else
+          return;
+        C.preventDefault();
+      }
+    }
+    function z(C) {
+      T.value = !0;
+    }
+    function O(C) {
+      if (A.value)
+        return ct(A.value, C);
+    }
+    return N(() => m(e.tag, {
+      ref: A,
+      class: ["v-list", {
+        "v-list--disabled": e.disabled,
+        "v-list--nav": e.nav,
+        "v-list--slim": e.slim
+      }, s.value, t.value, o.value, d.value, c.value, S.value, v.value, e.class],
+      style: [i.value, y.value, e.style],
+      tabindex: e.disabled ? -1 : 0,
+      role: "listbox",
+      "aria-activedescendant": void 0,
+      onFocusin: $,
+      onFocusout: Y,
+      onFocus: H,
+      onKeydown: R,
+      onMousedown: z
+    }, {
+      default: () => [m(De, {
+        items: n.value,
+        returnObject: e.returnObject
+      }, a)]
+    })), {
+      open: b,
+      select: u,
+      focus: O,
+      children: h,
+      parents: r,
+      getPath: f
+    };
+  }
+});
+Qe("css/revolugo.vlist.-Y4qkukF.css");
+export {
+  ve as V,
+  en as a,
+  Ft as b,
+  Ut as m,
+  Qt as u
+};
+//# sourceMappingURL=revolugo.vlist.BwlPoH0e.min.js.map