@volverjs/ui-vue 0.0.10-beta.9 → 0.0.11

package/dist/components/VvInputFile/VvInputFile.es.js

@@ -0,0 +1,1704 @@
+import { computed, isRef, defineComponent, h, inject, toRef, toRefs, getCurrentInstance, ref, watch, resolveComponent, createBlock, openBlock, resolveDynamicComponent, unref, mergeProps, withCtx, renderSlot, createTextVNode, toDisplayString, mergeDefaults, createCommentVNode, useId, useAttrs, useSlots, createElementBlock, Fragment, onBeforeUnmount, normalizeClass, createElementVNode, createVNode, withModifiers, normalizeProps, guardReactiveProps, createSlots } from "vue";
+import { useVModel } from "@vueuse/core";
+import Sortable from "vuedraggable";
+import { iconLoaded, Icon, addIcon } from "@iconify/vue";
+const ACTION_ICONS = {
+  add: "add",
+  edit: "edit",
+  download: "download"
+};
+const VvIconPropsDefaults = {
+  prefix: "normal"
+  /* normal */
+};
+var StorageType = /* @__PURE__ */ ((StorageType2) => {
+  StorageType2["local"] = "local";
+  StorageType2["session"] = "session";
+  return StorageType2;
+})(StorageType || {});
+var Side = /* @__PURE__ */ ((Side2) => {
+  Side2["left"] = "left";
+  Side2["right"] = "right";
+  Side2["top"] = "top";
+  Side2["bottom"] = "bottom";
+  return Side2;
+})(Side || {});
+var Position = /* @__PURE__ */ ((Position2) => {
+  Position2["before"] = "before";
+  Position2["after"] = "after";
+  return Position2;
+})(Position || {});
+var ButtonType = /* @__PURE__ */ ((ButtonType2) => {
+  ButtonType2["button"] = "button";
+  ButtonType2["submit"] = "submit";
+  ButtonType2["reset"] = "reset";
+  return ButtonType2;
+})(ButtonType || {});
+var ActionTag = /* @__PURE__ */ ((ActionTag2) => {
+  ActionTag2["nuxtLink"] = "nuxt-link";
+  ActionTag2["routerLink"] = "router-link";
+  ActionTag2["a"] = "a";
+  ActionTag2["button"] = "button";
+  return ActionTag2;
+})(ActionTag || {});
+const INJECTION_KEY_VOLVER = Symbol.for("volver");
+const INJECTION_KEY_BUTTON_GROUP = Symbol.for(
+  "buttonGroup"
+);
+const INJECTION_KEY_DROPDOWN_TRIGGER = Symbol.for(
+  "dropdownTrigger"
+);
+const INJECTION_KEY_DROPDOWN_ACTION = Symbol.for(
+  "dropdownAction"
+);
+const LinkProps = {
+  /**
+   * The router-link/nuxt-link property, if it is defined the button is rendered as a ruouter-link or nuxt-link.
+   * @see Documentation of [router-link](https://router.vuejs.org/api/#router-link) and [nuxt-link](https://nuxtjs.org/api/components-nuxt-link/)
+   */
+  to: {
+    type: [String, Object]
+  },
+  /**
+   * Anchor href
+   */
+  href: String,
+  /**
+   * Anchor target
+   */
+  target: String,
+  /**
+   * Anchor rel
+   */
+  rel: {
+    type: String,
+    default: "noopener noreferrer"
+  }
+};
+const ValidProps = {
+  /**
+   * Valid status
+   */
+  valid: { type: Boolean, default: false },
+  /**
+   * Valid label
+   */
+  validLabel: { type: [String, Array], default: void 0 }
+};
+const InvalidProps = {
+  /**
+   * Invalid status
+   */
+  invalid: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * Invalid label
+   */
+  invalidLabel: { type: [String, Array], default: void 0 }
+};
+const LoadingProps = {
+  /**
+   * Loading status
+   */
+  loading: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * Loading label
+   */
+  loadingLabel: {
+    type: String,
+    default: "Loading..."
+  }
+};
+const DisabledProps = {
+  /**
+   * Whether the form control is disabled
+   */
+  disabled: {
+    type: Boolean,
+    default: false
+  }
+};
+const RequiredProps = {
+  /**
+   * Whether the form control is required
+   */
+  required: {
+    type: Boolean,
+    default: false
+  }
+};
+const ActiveProps = {
+  /**
+   * Whether the item is active
+   */
+  active: {
+    type: Boolean,
+    default: false
+  }
+};
+const CurrentProps = {
+  /**
+   * Whether the item is current
+   */
+  current: {
+    type: Boolean,
+    default: false
+  }
+};
+const PressedProps = {
+  /**
+   * Whether the item is pressed
+   */
+  pressed: {
+    type: Boolean,
+    default: false
+  }
+};
+const LabelProps = {
+  /**
+   * The item label
+   */
+  label: {
+    type: [String, Number],
+    default: void 0
+  }
+};
+const ReadonlyProps = {
+  /**
+   * The value is not editable
+   */
+  readonly: {
+    type: Boolean,
+    default: false
+  }
+};
+const ModifiersProps = {
+  /**
+   * Component BEM modifiers
+   */
+  modifiers: {
+    type: [String, Array],
+    default: void 0
+  }
+};
+const HintProps = {
+  hintLabel: { type: String, default: "" }
+};
+const IconProps = {
+  /**
+   * VvIcon name or props
+   * @see VvIcon
+   */
+  icon: {
+    type: [String, Object],
+    default: void 0
+  },
+  /**
+   * VvIcon position
+   */
+  iconPosition: {
+    type: String,
+    default: Position.before,
+    validation: (value) => Object.values(Position).includes(value)
+  }
+};
+const UnselectableProps = {
+  /**
+   * If true the input will be unselectable
+   */
+  unselectable: { type: Boolean, default: true }
+};
+const IdProps = {
+  /**
+   * Global attribute id
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/id
+   */
+  id: [String, Number]
+};
+({
+  /**
+   * Dropdown placement
+   */
+  placement: {
+    default: Side.bottom
+  }
+});
+const IdNameProps = {
+  ...IdProps,
+  /**
+   * Input / Textarea name
+   * Name of the form control. Submitted with the form as part of a name/value pair
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#name
+   */
+  name: { type: String, required: true }
+};
+const ActionProps = {
+  ...DisabledProps,
+  ...LabelProps,
+  ...PressedProps,
+  ...ActiveProps,
+  ...CurrentProps,
+  ...LinkProps,
+  /**
+   * Button type
+   */
+  type: {
+    type: String,
+    default: ButtonType.button,
+    validator: (value) => Object.values(ButtonType).includes(value)
+  },
+  /**
+   * Button aria-label
+   */
+  ariaLabel: {
+    type: String,
+    default: void 0
+  },
+  /**
+   * Default tag for the action
+   */
+  defaultTag: {
+    type: String,
+    default: ActionTag.button
+  }
+};
+({
+  storageType: {
+    default: StorageType.local
+  }
+});
+const VvInputFileProps = {
+  ...IdNameProps,
+  ...ModifiersProps,
+  ...ValidProps,
+  ...InvalidProps,
+  ...HintProps,
+  ...LabelProps,
+  ...LoadingProps,
+  ...ReadonlyProps,
+  ...DisabledProps,
+  ...RequiredProps,
+  ...IconProps,
+  /**
+   * Input value
+   */
+  modelValue: {
+    type: Object
+  },
+  /**
+   * Whether to show progress bar
+   */
+  progress: { type: [Number, String], default: void 0 },
+  /**
+   * Input
+   * Text that appears in the form control when it has no value set
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#placeholder
+   */
+  placeholder: { type: String, default: void 0 },
+  /**
+   * File types to accept
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/accept
+   */
+  accept: { type: String, default: "*" },
+  /**
+   * Whether to allow multiple values
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input#multiple
+   */
+  multiple: { type: Boolean, default: false },
+  /**
+   * Front or rear camera
+   * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/capture
+   */
+  capture: {
+    type: String,
+    default: void 0,
+    validation: (value) => {
+      if (value === void 0) {
+        return true;
+      }
+      return ["user", "environment"].includes(value);
+    }
+  },
+  /**
+   * Max number of files
+   */
+  max: { type: [Number, String], default: void 0 },
+  /**
+   * Show drop area
+   */
+  dropArea: { type: Boolean, default: false },
+  /**
+   * Enable sorting
+   */
+  sortable: { type: Boolean, default: false },
+  /**
+   * Label for add button
+   */
+  labelAdd: {
+    type: String,
+    default: "Add file"
+  },
+  /**
+   * VvIcon name for add button
+   * @see VvIcon
+   */
+  iconAdd: {
+    type: [String, Object],
+    default: ACTION_ICONS.add
+  },
+  /**
+   * Label for replace button
+   */
+  labelReplace: {
+    type: String,
+    default: "Replace file"
+  },
+  /**
+   * VvIcon name for replace button
+   * @see VvIcon
+   */
+  iconReplace: {
+    type: [String, Object],
+    default: ACTION_ICONS.edit
+  },
+  /**
+   * Label for download button
+   */
+  labelDownload: {
+    type: String,
+    default: "Downlaod file"
+  },
+  /**
+   * VvIcon name for download button
+   * @see VvIcon
+   */
+  iconDownload: {
+    type: [String, Object],
+    default: ACTION_ICONS.download
+  },
+  /**
+   * Label for remove button
+   */
+  labelRemove: {
+    type: String,
+    default: "Remove file"
+  }
+};
+function acceptedMimeTypes(acceptValue) {
+  const mimeTypes = [];
+  const extensions = [];
+  const wildcards = [];
+  const acceptedTypes = acceptValue?.split(",").map((type) => type.trim().toLowerCase());
+  if (acceptedTypes?.length) {
+    acceptedTypes.forEach((type) => {
+      if (type.startsWith(".")) {
+        extensions.push(type);
+      } else if (type.includes("/*")) {
+        wildcards.push(type.replace("/*", ""));
+      } else {
+        mimeTypes.push(type);
+      }
+    });
+  }
+  return {
+    mimeTypes,
+    extensions,
+    wildcards
+  };
+}
+function filterFileList(fileList, acceptValue) {
+  if (!acceptValue || acceptValue.trim() === "" || acceptValue === "*") {
+    return Array.from(fileList);
+  }
+  const { mimeTypes, extensions, wildcards } = acceptedMimeTypes(acceptValue);
+  return Array.from(fileList).filter((file) => {
+    const fileType = file.type.toLowerCase();
+    const fileExtension = `.${file.name.split(".").pop()?.toLowerCase()}`;
+    const mimeMatches = mimeTypes.includes(fileType);
+    const wildcardMatches = wildcards.some((wildcard) => fileType.startsWith(`${wildcard}/`));
+    const extensionMatches = extensions.some((ext) => fileExtension === ext.toLowerCase());
+    return mimeMatches || wildcardMatches || extensionMatches;
+  });
+}
+function equals(obj1, obj2, field) {
+  return deepEquals(obj1, obj2);
+}
+function deepEquals(a, b) {
+  if (a === b)
+    return true;
+  if (a && b && typeof a == "object" && typeof b == "object") {
+    const arrA = Array.isArray(a);
+    const arrB = Array.isArray(b);
+    let i, length, key;
+    if (arrA && arrB) {
+      length = a.length;
+      if (length !== b.length)
+        return false;
+      for (i = length; i-- !== 0; ) {
+        if (!deepEquals(a[i], b[i]))
+          return false;
+      }
+      return true;
+    }
+    if (arrA !== arrB)
+      return false;
+    const dateA = a instanceof Date;
+    const dateB = b instanceof Date;
+    if (dateA !== dateB)
+      return false;
+    if (dateA && dateB)
+      return a.getTime() === b.getTime();
+    const regexpA = a instanceof RegExp;
+    const regexpB = b instanceof RegExp;
+    if (regexpA !== regexpB)
+      return false;
+    if (regexpA && regexpB)
+      return a.toString() === b.toString();
+    const keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length)
+      return false;
+    for (i = length; i-- !== 0; ) {
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
+        return false;
+    }
+    for (i = length; i-- !== 0; ) {
+      key = keys[i];
+      if (!deepEquals(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return Number.isNaN(a) && Number.isNaN(b);
+}
+function contains(value, list) {
+  if (value != null && list && list.length) {
+    for (const val of list) {
+      if (equals(value, val)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function joinLines(items) {
+  if (Array.isArray(items)) {
+    return items.filter((item) => isString(item)).join(" ");
+  }
+  return items;
+}
+function HintSlotFactory(propsOrRef, slots) {
+  const props = computed(() => {
+    if (isRef(propsOrRef)) {
+      return propsOrRef.value;
+    }
+    return propsOrRef;
+  });
+  const invalidLabel = computed(() => joinLines(props.value.invalidLabel));
+  const validLabel = computed(() => joinLines(props.value.validLabel));
+  const loadingLabel = computed(() => props.value.loadingLabel);
+  const hintLabel = computed(() => props.value.hintLabel);
+  const hasLoadingLabelOrSlot = computed(
+    () => Boolean(props.value.loading && (slots.loading || loadingLabel.value))
+  );
+  const hasInvalidLabelOrSlot = computed(
+    () => !hasLoadingLabelOrSlot.value && Boolean(
+      props.value.invalid && (slots.invalid || invalidLabel.value)
+    )
+  );
+  const hasValidLabelOrSlot = computed(
+    () => !hasLoadingLabelOrSlot.value && !hasInvalidLabelOrSlot.value && Boolean(props.value.valid && (slots.valid || validLabel.value))
+  );
+  const hasHintLabelOrSlot = computed(
+    () => !hasLoadingLabelOrSlot.value && !hasInvalidLabelOrSlot.value && !hasValidLabelOrSlot.value && Boolean(slots.hint || hintLabel.value)
+  );
+  const isVisible = computed(
+    () => hasInvalidLabelOrSlot.value || hasValidLabelOrSlot.value || hasLoadingLabelOrSlot.value || hasHintLabelOrSlot.value
+  );
+  const hintSlotScope = computed(() => ({
+    modelValue: props.value.modelValue,
+    valid: props.value.valid,
+    invalid: props.value.invalid,
+    loading: props.value.loading
+  }));
+  const HintSlot = defineComponent({
+    name: "HintSlot",
+    props: {
+      tag: {
+        type: String,
+        default: "small"
+      }
+    },
+    setup() {
+      return {
+        isVisible,
+        invalidLabel,
+        validLabel,
+        loadingLabel,
+        hintLabel,
+        hasInvalidLabelOrSlot,
+        hasValidLabelOrSlot,
+        hasLoadingLabelOrSlot,
+        hasHintLabelOrSlot
+      };
+    },
+    render() {
+      if (this.isVisible) {
+        let role;
+        if (this.hasInvalidLabelOrSlot) {
+          role = "alert";
+        }
+        if (this.hasValidLabelOrSlot) {
+          role = "status";
+        }
+        if (this.hasLoadingLabelOrSlot) {
+          return h(
+            this.tag,
+            {
+              role
+            },
+            this.$slots.loading?.() ?? this.loadingLabel
+          );
+        }
+        if (this.hasInvalidLabelOrSlot) {
+          return h(
+            this.tag,
+            {
+              role
+            },
+            this.$slots.invalid?.() ?? this.$slots.invalid ?? this.invalidLabel
+          );
+        }
+        if (this.hasValidLabelOrSlot) {
+          return h(
+            this.tag,
+            {
+              role
+            },
+            this.$slots.valid?.() ?? this.validLabel
+          );
+        }
+        return h(
+          this.tag,
+          {
+            role
+          },
+          this.$slots.hint?.() ?? this.$slots.hint ?? this.hintLabel
+        );
+      }
+      return null;
+    }
+  });
+  return {
+    hasInvalidLabelOrSlot,
+    hasHintLabelOrSlot,
+    hasValidLabelOrSlot,
+    hasLoadingLabelOrSlot,
+    hintSlotScope,
+    HintSlot
+  };
+}
+function useGroupStateInject(groupKey) {
+  const group = inject(groupKey, void 0);
+  const isInGroup = computed(() => group !== void 0);
+  function getGroupOrLocalRef(propName, props, emit) {
+    const groupPropValue = group?.[propName];
+    if (groupPropValue) {
+      return computed({
+        get() {
+          return groupPropValue.value;
+        },
+        set(value) {
+          groupPropValue.value = value;
+        }
+      });
+    }
+    const propRef = toRef(props, propName);
+    return computed({
+      get() {
+        return propRef.value;
+      },
+      set(value) {
+        if (emit) {
+          emit(`update:${propName}`, value);
+        }
+      }
+    });
+  }
+  return {
+    group,
+    isInGroup,
+    getGroupOrLocalRef
+  };
+}
+const VvButtonEvents = ["update:modelValue"];
+const VvButtonProps = {
+  ...ActionProps,
+  ...IdProps,
+  ...ModifiersProps,
+  ...UnselectableProps,
+  ...LoadingProps,
+  ...IconProps,
+  /**
+   * Button icon position
+   */
+  iconPosition: {
+    type: String,
+    default: Side.left,
+    validator: (value) => Object.values(Side).includes(value)
+  },
+  /**
+   * Loading icon
+   */
+  loadingIcon: { type: String, default: "eos-icons:bubble-loading" },
+  /**
+   * Enable button toggle
+   */
+  toggle: {
+    type: Boolean,
+    default: false
+  },
+  /**
+   * Button toggle value
+   */
+  value: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  /**
+   * Value associated with the unchecked state
+   */
+  uncheckedValue: {
+    type: [String, Number, Boolean],
+    default: void 0
+  },
+  /**
+   * Button toggle model value
+   */
+  modelValue: {
+    type: [String, Number, Boolean],
+    default: void 0
+  }
+};
+function useGroupProps(props, emit) {
+  const { group, isInGroup, getGroupOrLocalRef } = useGroupStateInject(INJECTION_KEY_BUTTON_GROUP);
+  const { id, iconPosition, icon, label, pressed } = toRefs(props);
+  const modelValue = getGroupOrLocalRef("modelValue", props, emit);
+  const toggle = getGroupOrLocalRef("toggle", props);
+  const unselectable = getGroupOrLocalRef("unselectable", props);
+  const multiple = computed(() => group?.multiple.value ?? false);
+  const modifiers = computed(() => {
+    let localModifiers = props.modifiers;
+    let groupModifiers = group?.modifiers.value;
+    const toReturn = /* @__PURE__ */ new Set();
+    if (localModifiers) {
+      if (!Array.isArray(localModifiers)) {
+        localModifiers = localModifiers.split(" ");
+      }
+      localModifiers.forEach((modifier) => toReturn.add(modifier));
+    }
+    if (groupModifiers) {
+      if (!Array.isArray(groupModifiers)) {
+        groupModifiers = groupModifiers.split(" ");
+      }
+      groupModifiers.forEach((modifier) => toReturn.add(modifier));
+    }
+    return Array.from(toReturn);
+  });
+  const disabled = computed(
+    () => Boolean(props.disabled || group?.disabled.value)
+  );
+  return {
+    // group props
+    group,
+    isInGroup,
+    modelValue,
+    toggle,
+    unselectable,
+    multiple,
+    modifiers,
+    disabled,
+    // local props
+    id,
+    pressed,
+    iconPosition,
+    icon,
+    label
+  };
+}
+const VvActionEvents = ["click", "mouseover", "mouseleave"];
+const VvActionProps = ActionProps;
+function useVolver() {
+  return inject(INJECTION_KEY_VOLVER, void 0);
+}
+function useInjectedDropdownTrigger() {
+  return inject(INJECTION_KEY_DROPDOWN_TRIGGER, {});
+}
+function useInjectedDropdownAction() {
+  return inject(INJECTION_KEY_DROPDOWN_ACTION, {});
+}
+const __default__$3 = {
+  name: "VvAction"
+};
+const _sfc_main$3 = /* @__PURE__ */ defineComponent({
+  ...__default__$3,
+  props: VvActionProps,
+  emits: VvActionEvents,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const instance = getCurrentInstance();
+    const volver = useVolver();
+    const element = ref(null);
+    __expose({ $el: element });
+    const {
+      reference: dropdownTriggerReference,
+      bus: dropdownEventBus,
+      aria: dropdownAria,
+      expanded: dropdownExpanded
+    } = useInjectedDropdownTrigger();
+    watch(
+      () => element.value,
+      (newValue) => {
+        if (dropdownTriggerReference) {
+          dropdownTriggerReference.value = newValue;
+        }
+      }
+    );
+    const pressed = computed(() => {
+      return props.pressed || dropdownExpanded?.value;
+    });
+    const { role } = useInjectedDropdownAction();
+    const hasTag = computed(() => {
+      switch (true) {
+        case props.disabled:
+          return ActionTag.button;
+        case props.to !== void 0:
+          return volver?.nuxt ? resolveComponent(ActionTag.nuxtLink) : ActionTag.routerLink;
+        case props.href !== void 0:
+          return ActionTag.a;
+        default:
+          return props.defaultTag;
+      }
+    });
+    const hasProps = computed(() => {
+      const toReturn = {
+        ...dropdownAria?.value,
+        ariaPressed: pressed.value ? true : void 0,
+        ariaLabel: props.ariaLabel,
+        role: role?.value
+      };
+      switch (hasTag.value) {
+        case ActionTag.a:
+          return {
+            ...toReturn,
+            href: props.href,
+            target: props.target,
+            rel: props.rel
+          };
+        case ActionTag.routerLink:
+        case ActionTag.nuxtLink:
+          return {
+            ...toReturn,
+            to: props.to,
+            target: props.target
+          };
+        case ActionTag.button:
+          return {
+            ...toReturn,
+            type: props.type,
+            disabled: props.disabled
+          };
+        default:
+          return toReturn;
+      }
+    });
+    function onClick(e) {
+      if (props.disabled) {
+        e.preventDefault();
+        return;
+      }
+      if (instance?.vnode.props?.onClick) {
+        emit("click", e);
+        return;
+      }
+      dropdownEventBus?.emit("click", e);
+    }
+    function onMouseover(e) {
+      if (instance?.vnode.props?.onMouseover) {
+        emit("mouseover", e);
+        return;
+      }
+      dropdownEventBus?.emit("mouseover", e);
+    }
+    function onMouseleave(e) {
+      if (instance?.vnode.props?.onMouseleave) {
+        emit("mouseleave", e);
+        return;
+      }
+      dropdownEventBus?.emit("mouseleave", e);
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(resolveDynamicComponent(unref(hasTag)), mergeProps(unref(hasProps), {
+        ref_key: "element",
+        ref: element,
+        class: {
+          active: _ctx.active,
+          pressed: unref(pressed),
+          disabled: _ctx.disabled,
+          current: _ctx.current
+        },
+        onClickPassive: onClick,
+        onMouseoverPassive: onMouseover,
+        onMouseleavePassive: onMouseleave
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            createTextVNode(
+              toDisplayString(_ctx.label),
+              1
+              /* TEXT */
+            )
+          ])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 16, ["class"]);
+    };
+  }
+});
+function useModifiers(prefix, modifiers, others) {
+  return computed(() => {
+    const toReturn = {
+      [prefix]: true
+    };
+    const modifiersArray = typeof modifiers?.value === "string" ? modifiers.value.split(" ") : modifiers?.value;
+    if (modifiersArray) {
+      if (Array.isArray(modifiersArray)) {
+        modifiersArray.forEach((modifier) => {
+          if (modifier) {
+            toReturn[`${prefix}--${modifier}`] = true;
+          }
+        });
+      }
+    }
+    if (others) {
+      Object.keys(others.value).forEach((key) => {
+        toReturn[`${prefix}--${key}`] = unref(others.value[key]);
+      });
+    }
+    return toReturn;
+  });
+}
+const __default__$2 = {
+  name: "VvIcon"
+};
+const _sfc_main$2 = /* @__PURE__ */ defineComponent({
+  ...__default__$2,
+  props: /* @__PURE__ */ mergeDefaults({
+    name: {},
+    color: {},
+    width: {},
+    height: {},
+    provider: {},
+    prefix: {},
+    src: {},
+    horizontalFlip: { type: Boolean },
+    verticalFlip: { type: Boolean },
+    flip: {},
+    mode: {},
+    inline: { type: Boolean },
+    rotate: {},
+    onLoad: { type: Function },
+    svg: {},
+    modifiers: {}
+  }, VvIconPropsDefaults),
+  setup(__props) {
+    const props = __props;
+    const hasRotate = computed(() => {
+      if (typeof props.rotate === "string") {
+        return Number.parseFloat(props.rotate);
+      }
+      return props.rotate;
+    });
+    const show = ref(true);
+    const volver = useVolver();
+    const { modifiers } = toRefs(props);
+    const bemCssClasses = useModifiers("vv-icon", modifiers);
+    const provider = computed(() => {
+      return props.provider || volver?.iconsProvider;
+    });
+    const icon = computed(() => {
+      const name = props.name ?? "";
+      const iconName = `@${provider.value}:${props.prefix}:${name}`;
+      if (iconLoaded(iconName)) {
+        return iconName;
+      }
+      const iconsCollection = volver?.iconsCollections.find(
+        (iconsCollection2) => {
+          const icon2 = `@${provider.value}:${iconsCollection2.prefix}:${name}`;
+          return iconLoaded(icon2);
+        }
+      );
+      if (iconsCollection) {
+        return `@${provider.value}:${iconsCollection.prefix}:${name}`;
+      }
+      return name;
+    });
+    function getSvgContent(svg) {
+      let dom;
+      if (typeof window === "undefined") {
+        const { JSDOM } = require("jsdom");
+        dom = new JSDOM().window;
+      }
+      const domParser = dom ? new dom.DOMParser() : new window.DOMParser();
+      const svgDomString = domParser.parseFromString(svg, "text/html");
+      const svgEl = svgDomString.querySelector("svg");
+      return svgEl;
+    }
+    function addIconFromSvg(svg) {
+      const svgContentEl = getSvgContent(svg);
+      const svgContent = svgContentEl?.innerHTML.trim() || "";
+      if (svgContentEl && svgContent) {
+        addIcon(`@${provider.value}:${props.prefix}:${props.name}`, {
+          body: svgContent,
+          // Set height and width from svg content
+          height: svgContentEl.viewBox.baseVal.height,
+          width: svgContentEl.viewBox.baseVal.width
+        });
+      }
+    }
+    if (volver) {
+      if (props.src && !iconLoaded(`@${provider.value}:${props.prefix}:${props.name}`)) {
+        show.value = false;
+        volver.fetchIcon(props.src).then((svg) => {
+          if (svg) {
+            addIconFromSvg(svg);
+            show.value = true;
+          }
+        }).catch((e) => {
+          throw new Error(`Error during fetch icon: ${e?.message}`);
+        });
+      }
+    }
+    if (props.svg) {
+      addIconFromSvg(props.svg);
+    }
+    return (_ctx, _cache) => {
+      return unref(show) ? (openBlock(), createBlock(unref(Icon), mergeProps({
+        key: 0,
+        class: unref(bemCssClasses)
+      }, {
+        inline: __props.inline,
+        width: __props.width,
+        height: __props.height,
+        horizontalFlip: __props.horizontalFlip,
+        verticalFlip: __props.verticalFlip,
+        flip: __props.flip,
+        rotate: unref(hasRotate),
+        color: __props.color,
+        icon: unref(icon)
+      }, { onLoad: __props.onLoad }), null, 16, ["class", "onLoad"])) : createCommentVNode("v-if", true);
+    };
+  }
+});
+function useUniqueId(id) {
+  return computed(() => String(id?.value || useId()));
+}
+function useComponentIcon(icon, iconPosition) {
+  const hasIcon = computed(() => {
+    if (typeof icon?.value === "string") {
+      return { name: icon?.value };
+    }
+    return icon?.value;
+  });
+  const hasIconBefore = computed(
+    () => iconPosition?.value === Position.before ? hasIcon.value : void 0
+  );
+  const hasIconAfter = computed(
+    () => iconPosition?.value === Position.after ? hasIcon.value : void 0
+  );
+  const hasIconLeft = computed(
+    () => iconPosition?.value === Side.left ? hasIcon.value : void 0
+  );
+  const hasIconRight = computed(
+    () => iconPosition?.value === Side.right ? hasIcon.value : void 0
+  );
+  const hasIconTop = computed(
+    () => iconPosition?.value === Side.top ? hasIcon.value : void 0
+  );
+  const hasIconBottom = computed(
+    () => iconPosition?.value === Side.bottom ? hasIcon.value : void 0
+  );
+  return {
+    hasIcon,
+    hasIconLeft,
+    hasIconRight,
+    hasIconTop,
+    hasIconBottom,
+    hasIconBefore,
+    hasIconAfter
+  };
+}
+const _hoisted_1$1 = {
+  key: 1,
+  class: "vv-button__label"
+};
+const _hoisted_2$1 = {
+  key: 1,
+  class: "vv-button__label"
+};
+const __default__$1 = {
+  name: "VvButton",
+  inheritAttrs: false
+};
+const _sfc_main$1 = /* @__PURE__ */ defineComponent({
+  ...__default__$1,
+  props: VvButtonProps,
+  emits: VvButtonEvents,
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const attrs = useAttrs();
+    const slots = useSlots();
+    const {
+      id,
+      modifiers,
+      iconPosition,
+      icon,
+      label,
+      modelValue,
+      disabled,
+      toggle,
+      unselectable
+    } = useGroupProps(props, emit);
+    const hasId = useUniqueId(id);
+    const name = computed(() => attrs?.name || hasId.value);
+    const element = ref(null);
+    const $el = computed(() => element.value?.$el);
+    __expose({ $el });
+    const pressed = computed(() => {
+      if (!toggle.value) {
+        return props.pressed;
+      }
+      if (Array.isArray(modelValue.value)) {
+        return contains(name.value, modelValue.value);
+      }
+      return equals(name.value, modelValue.value);
+    });
+    const bemCssClasses = useModifiers(
+      "vv-button",
+      modifiers,
+      computed(() => ({
+        "reverse": [Side.right, Side.bottom].includes(
+          iconPosition.value
+        ),
+        "column": [Side.top, Side.bottom].includes(
+          iconPosition.value
+        ),
+        "icon-only": Boolean(
+          icon?.value && !label?.value && !slots.default
+        )
+      }))
+    );
+    const { hasIcon } = useComponentIcon(icon);
+    const toggleValue = computed(() => {
+      return props.value !== void 0 ? props.value : name.value;
+    });
+    const hasListeners = computed(() => {
+      if (!toggle.value) {
+        return void 0;
+      }
+      return {
+        onClick
+      };
+    });
+    function onClick() {
+      if (toggle.value) {
+        if (Array.isArray(modelValue.value)) {
+          if (contains(toggleValue.value, modelValue.value)) {
+            if (unselectable.value) {
+              modelValue.value = modelValue.value.filter(
+                (n) => n !== toggleValue.value
+              );
+            }
+            return;
+          }
+          modelValue.value.push(toggleValue.value);
+          return;
+        }
+        if (toggleValue.value === modelValue.value && unselectable.value) {
+          modelValue.value = props.uncheckedValue;
+          return;
+        }
+        modelValue.value = toggleValue.value;
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(_sfc_main$3, mergeProps({
+        ...unref(attrs),
+        ...unref(hasListeners),
+        disabled: unref(disabled),
+        pressed: unref(pressed),
+        active: _ctx.active,
+        type: _ctx.type,
+        to: _ctx.to,
+        href: _ctx.href,
+        target: _ctx.target,
+        rel: _ctx.rel,
+        ariaLabel: _ctx.ariaLabel
+      }, {
+        id: unref(hasId),
+        ref_key: "element",
+        ref: element,
+        class: unref(bemCssClasses)
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default", {}, () => [
+            _ctx.loading ? renderSlot(_ctx.$slots, "loading", { key: 0 }, () => [
+              _ctx.loadingIcon ? (openBlock(), createBlock(_sfc_main$2, {
+                key: 0,
+                class: "vv-button__loading-icon",
+                name: _ctx.loadingIcon
+              }, null, 8, ["name"])) : createCommentVNode("v-if", true),
+              _ctx.loadingLabel ? (openBlock(), createElementBlock(
+                "span",
+                _hoisted_1$1,
+                toDisplayString(_ctx.loadingLabel),
+                1
+                /* TEXT */
+              )) : createCommentVNode("v-if", true)
+            ]) : (openBlock(), createElementBlock(
+              Fragment,
+              { key: 1 },
+              [
+                renderSlot(_ctx.$slots, "before"),
+                unref(hasIcon) ? (openBlock(), createBlock(
+                  _sfc_main$2,
+                  mergeProps({ key: 0 }, unref(hasIcon), { class: "vv-button__icon" }),
+                  null,
+                  16
+                  /* FULL_PROPS */
+                )) : createCommentVNode("v-if", true),
+                unref(label) ? (openBlock(), createElementBlock("span", _hoisted_2$1, [
+                  renderSlot(_ctx.$slots, "label", {}, () => [
+                    createTextVNode(
+                      toDisplayString(unref(label)),
+                      1
+                      /* TEXT */
+                    )
+                  ])
+                ])) : createCommentVNode("v-if", true),
+                renderSlot(_ctx.$slots, "after")
+              ],
+              64
+              /* STABLE_FRAGMENT */
+            ))
+          ])
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 16, ["id", "class"]);
+    };
+  }
+});
+function useDefaults(componentName, propsDefinition, props) {
+  const volver = useVolver();
+  const volverComponentDefaults = computed(() => {
+    if (!volver || !volver.defaults.value?.[componentName]) {
+      return void 0;
+    }
+    return volver.defaults.value[componentName];
+  });
+  return computed(() => {
+    if (volverComponentDefaults.value === void 0) {
+      return props;
+    }
+    const componentDefaults = volverComponentDefaults.value;
+    const simplifiedPropsDefinition = propsDefinition;
+    const simplifiedProps = props;
+    return Object.keys(simplifiedPropsDefinition).reduce((acc, key) => {
+      const propValue = simplifiedProps[key];
+      acc[key] = propValue;
+      if (key in componentDefaults) {
+        if (Array.isArray(simplifiedPropsDefinition[key])) {
+          const typeArray = simplifiedPropsDefinition[key];
+          if (typeArray.length) {
+            const typeFunction = typeArray[0];
+            if (typeFunction === propValue) {
+              acc[key] = componentDefaults[key];
+            }
+          }
+        }
+        if (typeof simplifiedPropsDefinition[key] === "function") {
+          const typeFunction = simplifiedPropsDefinition[key];
+          if (typeFunction() === propValue) {
+            acc[key] = componentDefaults[key];
+          }
+        }
+        if (typeof simplifiedPropsDefinition[key] === "object") {
+          let defaultValue = simplifiedPropsDefinition[key].default;
+          if (typeof defaultValue === "function") {
+            defaultValue = defaultValue();
+          }
+          if (typeof defaultValue === "object") {
+            if (JSON.stringify(defaultValue) === JSON.stringify(propValue)) {
+              acc[key] = componentDefaults[key];
+            }
+          } else if (defaultValue === propValue) {
+            acc[key] = componentDefaults[key];
+          }
+        }
+      }
+      return acc;
+    }, {});
+  });
+}
+const _hoisted_1 = ["for"];
+const _hoisted_2 = { class: "vv-input-file__preview" };
+const _hoisted_3 = ["src", "alt"];
+const _hoisted_4 = { class: "vv-input-file__wrapper" };
+const _hoisted_5 = ["id", "readonly", "disabled", "required", "placeholder", "aria-describedby", "aria-invalid", "aria-errormessage", "multiple", "accept", "capture", "name"];
+const _hoisted_6 = ["value"];
+const _hoisted_7 = ["onClick"];
+const _hoisted_8 = ["title", "onClick"];
+const _hoisted_9 = { class: "vv-input-file__item-name" };
+const _hoisted_10 = { class: "vv-input-file__item-info" };
+const _hoisted_11 = ["title", "disabled", "onClick"];
+const __default__ = {
+  name: "VvInputFile"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...__default__,
+  props: VvInputFileProps,
+  emits: ["remove", "download", "update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const slots = useSlots();
+    const propsDefaults = useDefaults(
+      "VvInputFile",
+      VvInputFileProps,
+      props
+    );
+    const { modifiers, id, readonly, disabled, icon, iconPosition, iconDownload } = toRefs(props);
+    const hasId = useUniqueId(id);
+    const hasHintId = computed(() => `${hasId.value}-hint`);
+    const hasProgress = computed(() => {
+      if (!props.progress) {
+        return false;
+      }
+      const progress = typeof props.progress === "string" ? Number.parseInt(props.progress) : props.progress;
+      return progress > 0 && progress < 100;
+    });
+    const { hasIconBefore, hasIconAfter } = useComponentIcon(icon, iconPosition);
+    const { hasIcon: hasIconDownload } = useComponentIcon(iconDownload);
+    const bemCssClasses = useModifiers(
+      "vv-input-file",
+      modifiers,
+      computed(() => ({
+        "valid": props.valid === true,
+        "invalid": props.invalid === true,
+        "loading": props.loading && !hasProgress.value,
+        "disabled": props.disabled,
+        "required": props.required,
+        "readonly": props.readonly,
+        "dragging": isDragging.value,
+        "icon-before": !!hasIconBefore.value,
+        "icon-after": !!hasIconAfter.value,
+        "drop-area": hasDropArea.value
+      }))
+    );
+    const {
+      HintSlot,
+      hasHintLabelOrSlot,
+      hasInvalidLabelOrSlot,
+      hintSlotScope
+    } = HintSlotFactory(propsDefaults, slots);
+    const localModelValue = useVModel(props, "modelValue", emit);
+    const files = computed({
+      get: () => {
+        if (!localModelValue.value || !Array.isArray(localModelValue.value) && !localModelValue.value?.name) {
+          return [];
+        }
+        return Array.isArray(localModelValue.value) ? localModelValue.value : [localModelValue.value];
+      },
+      set: (value) => {
+        if (isMultiple.value) {
+          localModelValue.value = value;
+          return;
+        }
+        localModelValue.value = value?.[0];
+      }
+    });
+    const isDisabledOrReadonly = computed(() => props.disabled || props.readonly);
+    const hasMax = computed(() => {
+      return typeof props.max === "string" ? Number.parseInt(props.max) : props.max;
+    });
+    const hasDropArea = computed(() => {
+      return props.dropArea && !isDisabledOrReadonly.value;
+    });
+    const isMultiple = computed(() => {
+      if (!props.multiple) {
+        return false;
+      }
+      if (!hasMax.value) {
+        return true;
+      }
+      return hasMax.value - files.value.length > 1;
+    });
+    const isDragging = ref(false);
+    const inputEl = ref();
+    function onDragenter() {
+      isDragging.value = true;
+    }
+    function onDragleave() {
+      isDragging.value = false;
+    }
+    function onDrop(event) {
+      if (!event.dataTransfer?.files) {
+        return;
+      }
+      isDragging.value = false;
+      addFiles(event.dataTransfer?.files);
+    }
+    function onChange() {
+      if (!inputEl.value?.files) {
+        return;
+      }
+      addFiles(inputEl.value.files);
+      inputEl.value.value = "";
+    }
+    function addFiles(uploadedFiles) {
+      const filteredFiles = filterFileList(uploadedFiles, props.accept);
+      if (!props.multiple) {
+        if (Array.isArray(localModelValue.value)) {
+          localModelValue.value = filteredFiles;
+          return;
+        }
+        localModelValue.value = filteredFiles[0];
+        return;
+      }
+      let toReturn = [];
+      if (!Array.isArray(localModelValue.value) && localModelValue.value) {
+        toReturn = [localModelValue.value];
+      } else {
+        toReturn = localModelValue.value && Array.isArray(localModelValue.value) ? [...localModelValue.value] : toReturn;
+      }
+      for (const file of filteredFiles) {
+        if (hasMax.value && toReturn.length >= hasMax.value) {
+          break;
+        }
+        toReturn.push(file);
+      }
+      localModelValue.value = toReturn;
+      selectedFileIndex.value = toReturn.length - 1;
+    }
+    function onClickDropArea() {
+      if (!inputEl.value) {
+        return;
+      }
+      if (!isDisabledOrReadonly.value) {
+        inputEl.value.click();
+      }
+    }
+    function onClickRemoveFile(index) {
+      const toRemove = !Array.isArray(localModelValue.value) ? localModelValue.value : localModelValue.value[index];
+      if (!toRemove) {
+        return;
+      }
+      emit("remove", toRemove);
+      if (!Array.isArray(localModelValue.value)) {
+        localModelValue.value = void 0;
+        return;
+      }
+      if (selectedFileIndex.value === index) {
+        selectedFileIndex.value = 0;
+      }
+      const newModelValue = [...localModelValue.value];
+      newModelValue.splice(index, 1);
+      localModelValue.value = newModelValue;
+    }
+    const selectedFileIndex = ref(0);
+    const PREVIEW_MIME_TYPES = ["image/jpeg", "image/png"];
+    const previewSrc = computed(() => {
+      if (files.value.length === 0) {
+        return;
+      }
+      if (!files.value[selectedFileIndex.value]) {
+        return void 0;
+      }
+      if (files.value[selectedFileIndex.value] instanceof File) {
+        const currentFile2 = files.value[selectedFileIndex.value];
+        if (!PREVIEW_MIME_TYPES.includes(currentFile2.type)) {
+          return void 0;
+        }
+        return URL.createObjectURL(currentFile2);
+      }
+      const currentFile = files.value[selectedFileIndex.value];
+      if (currentFile.thumbnailUrl) {
+        return currentFile.thumbnailUrl;
+      }
+      if (!PREVIEW_MIME_TYPES.includes(currentFile.type)) {
+        return void 0;
+      }
+      return currentFile.url;
+    });
+    watch(previewSrc, (_newValue, oldValue) => {
+      if (oldValue) {
+        URL.revokeObjectURL(oldValue);
+      }
+    });
+    onBeforeUnmount(() => {
+      if (previewSrc.value) {
+        URL.revokeObjectURL(previewSrc.value);
+      }
+    });
+    function formatBytes(bytes, decimals) {
+      if (!bytes) {
+        return;
+      }
+      if (bytes === 0)
+        return "0 Bytes";
+      const k = 1024;
+      const dm = 2;
+      const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+      const i = Math.floor(Math.log(bytes) / Math.log(k));
+      return `${Number.parseFloat((bytes / k ** i).toFixed(dm))} ${sizes[i]}`;
+    }
+    function onClickDownloadFile(file) {
+      emit("download", file);
+      const href = file instanceof File ? URL.createObjectURL(file) : file.url;
+      if (!href) {
+        return;
+      }
+      const link = document.createElement("a");
+      link.href = href;
+      link.setAttribute("download", file.name);
+      document.body.appendChild(link);
+      link.click();
+      document.body.removeChild(link);
+      URL.revokeObjectURL(link.href);
+    }
+    function onClickSelectFile(index) {
+      selectedFileIndex.value = index;
+    }
+    const dropdAreaActionLabel = computed(() => {
+      if (files.value.length === 0 || isMultiple.value) {
+        return props.labelAdd;
+      }
+      return props.labelReplace;
+    });
+    const dropAreaActionIcon = computed(() => {
+      if (files.value.length === 0 || isMultiple.value) {
+        return props.iconAdd;
+      }
+      return props.iconReplace;
+    });
+    function onSortEnd({ newIndex }) {
+      if (newIndex !== null) {
+        selectedFileIndex.value = newIndex;
+      }
+    }
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock(
+        "div",
+        {
+          class: normalizeClass(unref(bemCssClasses))
+        },
+        [
+          _ctx.label ? (openBlock(), createElementBlock("label", {
+            key: 0,
+            for: unref(hasId)
+          }, toDisplayString(_ctx.label), 9, _hoisted_1)) : createCommentVNode("v-if", true),
+          hasDropArea.value ? (openBlock(), createElementBlock(
+            "div",
+            {
+              key: 1,
+              class: "vv-input-file__drop-area",
+              onDragenter: withModifiers(onDragenter, ["prevent", "stop"]),
+              onDragleave: withModifiers(onDragleave, ["prevent", "stop"]),
+              onDrop: withModifiers(onDrop, ["prevent", "stop"]),
+              onDragover: _cache[0] || (_cache[0] = withModifiers(() => {
+              }, ["prevent", "stop"])),
+              onClick: withModifiers(onClickDropArea, ["stop"])
+            },
+            [
+              renderSlot(_ctx.$slots, "drop-area", {}, () => [
+                createElementVNode("picture", _hoisted_2, [
+                  previewSrc.value ? (openBlock(), createElementBlock("img", {
+                    key: 0,
+                    src: previewSrc.value,
+                    alt: files.value[selectedFileIndex.value].name
+                  }, null, 8, _hoisted_3)) : createCommentVNode("v-if", true)
+                ]),
+                !unref(readonly) ? (openBlock(), createBlock(_sfc_main$1, {
+                  key: 0,
+                  modifiers: "action",
+                  label: !previewSrc.value ? dropdAreaActionLabel.value : void 0,
+                  title: previewSrc.value ? dropdAreaActionLabel.value : void 0,
+                  disabled: unref(disabled),
+                  class: normalizeClass({
+                    "vv-input-file__drop-area-action": previewSrc.value
+                  }),
+                  icon: dropAreaActionIcon.value,
+                  onClick: withModifiers(onClickDropArea, ["stop"])
+                }, null, 8, ["label", "title", "disabled", "class", "icon"])) : createCommentVNode("v-if", true)
+              ])
+            ],
+            32
+            /* NEED_HYDRATION */
+          )) : createCommentVNode("v-if", true),
+          createElementVNode("div", _hoisted_4, [
+            unref(hasIconBefore) ? (openBlock(), createBlock(
+              _sfc_main$2,
+              normalizeProps(mergeProps({ key: 0 }, unref(hasIconBefore))),
+              null,
+              16
+              /* FULL_PROPS */
+            )) : createCommentVNode("v-if", true),
+            createElementVNode("input", {
+              id: unref(hasId),
+              ref_key: "inputEl",
+              ref: inputEl,
+              type: "file",
+              readonly: unref(readonly),
+              disabled: unref(disabled),
+              required: _ctx.required,
+              placeholder: _ctx.placeholder,
+              "aria-describedby": unref(hasHintLabelOrSlot) ? hasHintId.value : void 0,
+              "aria-invalid": _ctx.invalid,
+              "aria-errormessage": unref(hasInvalidLabelOrSlot) ? hasHintId.value : void 0,
+              multiple: isMultiple.value,
+              accept: _ctx.accept,
+              capture: _ctx.capture,
+              name: _ctx.name,
+              onChange
+            }, null, 40, _hoisted_5),
+            hasProgress.value ? (openBlock(), createElementBlock("progress", {
+              key: 1,
+              class: "vv-input-file__progress",
+              value: _ctx.progress,
+              max: "100"
+            }, toDisplayString(_ctx.progress) + "% ", 9, _hoisted_6)) : createCommentVNode("v-if", true),
+            unref(hasIconAfter) ? (openBlock(), createBlock(
+              _sfc_main$2,
+              normalizeProps(mergeProps({ key: 2 }, unref(hasIconAfter))),
+              null,
+              16
+              /* FULL_PROPS */
+            )) : createCommentVNode("v-if", true)
+          ]),
+          createVNode(unref(Sortable), {
+            modelValue: files.value,
+            "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => files.value = $event),
+            tag: "ul",
+            class: "vv-input-file__list",
+            "item-key": "name",
+            move: () => _ctx.sortable,
+            onEnd: onSortEnd
+          }, {
+            item: withCtx(({ element: file, index }) => [
+              createElementVNode("li", {
+                class: normalizeClass(["vv-input-file__item", {
+                  "active": index === selectedFileIndex.value && hasDropArea.value && files.value.length > 1,
+                  "cursor-move": _ctx.sortable
+                }]),
+                onClick: withModifiers(($event) => onClickSelectFile(index), ["stop"])
+              }, [
+                unref(hasIconDownload) ? (openBlock(), createElementBlock("button", {
+                  key: 0,
+                  type: "button",
+                  class: "vv-input-file__item-action",
+                  title: _ctx.labelDownload,
+                  onClick: withModifiers(($event) => onClickDownloadFile(file), ["stop"])
+                }, [
+                  createVNode(
+                    _sfc_main$2,
+                    normalizeProps(guardReactiveProps(unref(hasIconDownload))),
+                    null,
+                    16
+                    /* FULL_PROPS */
+                  )
+                ], 8, _hoisted_8)) : createCommentVNode("v-if", true),
+                createElementVNode(
+                  "div",
+                  _hoisted_9,
+                  toDisplayString(file.name),
+                  1
+                  /* TEXT */
+                ),
+                createElementVNode(
+                  "small",
+                  _hoisted_10,
+                  toDisplayString(formatBytes(file.size)),
+                  1
+                  /* TEXT */
+                ),
+                !unref(readonly) ? (openBlock(), createElementBlock("button", {
+                  key: 1,
+                  type: "button",
+                  class: "vv-input-file__item-remove",
+                  title: _ctx.labelRemove,
+                  disabled: unref(disabled),
+                  onClick: withModifiers(($event) => onClickRemoveFile(index), ["stop"])
+                }, null, 8, _hoisted_11)) : createCommentVNode("v-if", true)
+              ], 10, _hoisted_7)
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["modelValue", "move"]),
+          createVNode(unref(HintSlot), {
+            id: hasHintId.value,
+            class: "vv-input-file__hint"
+          }, createSlots({
+            _: 2
+            /* DYNAMIC */
+          }, [
+            _ctx.$slots.hint ? {
+              name: "hint",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "hint", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "0"
+            } : void 0,
+            _ctx.$slots.loading ? {
+              name: "loading",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "loading", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "1"
+            } : void 0,
+            _ctx.$slots.valid ? {
+              name: "valid",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "valid", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "2"
+            } : void 0,
+            _ctx.$slots.invalid ? {
+              name: "invalid",
+              fn: withCtx(() => [
+                renderSlot(_ctx.$slots, "invalid", normalizeProps(guardReactiveProps(unref(hintSlotScope))))
+              ]),
+              key: "3"
+            } : void 0
+          ]), 1032, ["id"])
+        ],
+        2
+        /* CLASS */
+      );
+    };
+  }
+});
+export {
+  _sfc_main as default
+};