@nutui/nutui 4.0.12-beta.1 → 4.0.12

package/dist/packages/_es/Form.js

@@ -1,125 +1,196 @@
-var $ = Object.getOwnPropertySymbols;
-var F = Object.prototype.hasOwnProperty, I = Object.prototype.propertyIsEnumerable;
-var x = (l, i) => {
-  var m = {};
-  for (var o in l)
-    F.call(l, o) && i.indexOf(o) < 0 && (m[o] = l[o]);
-  if (l != null && $)
-    for (var o of $(l))
-      i.indexOf(o) < 0 && I.call(l, o) && (m[o] = l[o]);
-  return m;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
 };
-import { g as T, h as A, f as N, c as W } from "./component-234624bc.js";
-import { computed as q, reactive as G, provide as U, watch as z, resolveComponent as D, openBlock as H, createElementBlock as J, withModifiers as K, createVNode as L, withCtx as Q, renderSlot as X } from "vue";
-import C from "./CellGroup.js";
-import { _ as Y } from "./_plugin-vue_export-helper-dad06003.js";
+import { g as isObject, h as getPropByPath, f as isPromise, c as createComponent } from "./component-81a4c1d0.js";
+import { computed, reactive, provide, watch, resolveComponent, openBlock, createElementBlock, withModifiers, createVNode, withCtx, renderSlot } from "vue";
+import CellGroup from "./CellGroup.js";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-cc2b3d55.js";
 import "../locale/lang";
-const Z = (l) => ({
-  props: {
-    modelValue: {
-      type: Object,
-      default: {}
-    },
-    rules: {
-      type: Object,
-      default: {}
-    }
-  },
-  components: l,
-  emits: ["validate"],
-  setup(i, { emit: m, slots: o }) {
-    const f = q(() => G({}));
-    U("formErrorTip", f);
-    const _ = () => {
-      Object.keys(f.value).forEach((s) => {
-        f.value[s] = "";
-      });
-    }, g = () => {
-      _();
-    };
-    z(
-      () => i.modelValue,
-      () => {
-        _();
+const component = (components) => {
+  return {
+    props: {
+      modelValue: {
+        type: Object,
+        default: {}
       },
-      { immediate: !0 }
-    );
-    const y = (s) => {
-      let n = [];
-      return s.forEach((e) => {
-        var c, t, a, u;
-        let r = e.type;
-        r = r.name || r, r == "nut-form-item" || r != null && r.toString().endsWith("form-item") ? n.push({
-          prop: (c = e.props) == null ? void 0 : c.prop,
-          rules: ((t = e.props) == null ? void 0 : t.rules) || []
-        }) : Array.isArray(e.children) && ((a = e.children) != null && a.length) ? n = n.concat(y(e.children)) : T(e.children) && Object.keys(e.children) && (u = e.children) != null && u.default && (e.children = e.children.default(), n = n.concat(y(e.children)));
-      }), n;
-    }, P = (s) => {
-      s.message && m("validate", s), f.value[s.prop] = s.message;
-    }, j = (s) => {
-      const { rules: n, prop: e } = s, r = (b) => new Promise((h, d) => {
-        try {
-          P(b), h(b);
-        } catch (k) {
-          d(k);
-        }
-      });
-      e || console.warn("[NutUI] <FormItem> 使用 rules 校验规则时 , 必须设置 prop 参数");
-      const c = A(i.modelValue, e || "");
-      P({ prop: e, message: "" });
-      const t = i.rules || {}, a = [...(t == null ? void 0 : t[e]) || [], ...n];
-      for (; a.length; ) {
-        const u = a.shift(), { validator: h } = u, d = x(u, ["validator"]), { required: k, regex: O, message: S } = d, p = { prop: e, message: S };
-        if (k && !c && c !== 0 || O && !O.test(String(c)))
-          return r(p);
-        if (h) {
-          const w = h(c, d);
-          if (N(w))
-            return new Promise((V, B) => {
-              w.then((E) => {
-                E ? V(!0) : (P(p), V(p));
-              }).catch((E) => B(E));
+      rules: {
+        type: Object,
+        default: {}
+      }
+    },
+    components,
+    emits: ["validate"],
+    setup(props, { emit, slots }) {
+      const formErrorTip = computed(() => reactive({}));
+      provide("formErrorTip", formErrorTip);
+      const clearErrorTips = () => {
+        Object.keys(formErrorTip.value).forEach((item) => {
+          formErrorTip.value[item] = "";
+        });
+      };
+      const reset = () => {
+        clearErrorTips();
+      };
+      watch(
+        () => props.modelValue,
+        () => {
+          clearErrorTips();
+        },
+        { immediate: true }
+      );
+      const findFormItem = (vnodes) => {
+        let task = [];
+        vnodes.forEach((vnode) => {
+          var _a, _b, _c, _d;
+          let type = vnode.type;
+          type = type.name || type;
+          if (type == "nut-form-item" || (type == null ? void 0 : type.toString().endsWith("form-item"))) {
+            task.push({
+              prop: (_a = vnode.props) == null ? void 0 : _a["prop"],
+              rules: ((_b = vnode.props) == null ? void 0 : _b["rules"]) || []
             });
-          if (!w)
-            return r(p);
+          } else if (Array.isArray(vnode.children) && ((_c = vnode.children) == null ? void 0 : _c.length)) {
+            task = task.concat(findFormItem(vnode.children));
+          } else if (isObject(vnode.children) && Object.keys(vnode.children)) {
+            if ((_d = vnode.children) == null ? void 0 : _d.default) {
+              vnode.children = vnode.children.default();
+              task = task.concat(findFormItem(vnode.children));
+            }
+          }
+        });
+        return task;
+      };
+      const tipMessage = (errorMsg) => {
+        if (errorMsg.message) {
+          emit("validate", errorMsg);
         }
-      }
-      return Promise.resolve(!0);
-    }, v = (s = "") => new Promise((n, e) => {
-      try {
-        const c = y(o.default()).map((t) => s ? s == t.prop ? j(t) : Promise.resolve(!0) : j(t));
-        Promise.all(c).then((t) => {
-          t = t.filter((u) => u != !0);
-          const a = { valid: !0, errors: [] };
-          t.length && (a.valid = !1, a.errors = t), n(a);
+        formErrorTip.value[errorMsg.prop] = errorMsg.message;
+      };
+      const checkRule = (item) => {
+        const { rules, prop } = item;
+        const _Promise = (errorMsg) => {
+          return new Promise((resolve, reject) => {
+            try {
+              tipMessage(errorMsg);
+              resolve(errorMsg);
+            } catch (error) {
+              reject(error);
+            }
+          });
+        };
+        if (!prop) {
+          console.warn("[NutUI] <FormItem> 使用 rules 校验规则时 , 必须设置 prop 参数");
+        }
+        const value = getPropByPath(props.modelValue, prop || "");
+        tipMessage({ prop, message: "" });
+        const formRules = props.rules || {};
+        const _rules = [...(formRules == null ? void 0 : formRules[prop]) || [], ...rules];
+        while (_rules.length) {
+          const rule = _rules.shift();
+          const _a = rule, { validator } = _a, ruleWithoutValidator = __objRest(_a, ["validator"]);
+          const { required, regex, message } = ruleWithoutValidator;
+          const errorMsg = { prop, message };
+          if (required) {
+            if (!value && value !== 0) {
+              return _Promise(errorMsg);
+            }
+          }
+          if (regex && !regex.test(String(value))) {
+            return _Promise(errorMsg);
+          }
+          if (validator) {
+            const result = validator(value, ruleWithoutValidator);
+            if (isPromise(result)) {
+              return new Promise((r, j) => {
+                result.then((res) => {
+                  if (!res) {
+                    tipMessage(errorMsg);
+                    r(errorMsg);
+                  } else {
+                    r(true);
+                  }
+                }).catch((e) => j(e));
+              });
+            } else {
+              if (!result) {
+                return _Promise(errorMsg);
+              }
+            }
+          }
+        }
+        return Promise.resolve(true);
+      };
+      const validate = (customProp = "") => {
+        return new Promise((resolve, reject) => {
+          try {
+            const task = findFormItem(slots.default());
+            const errors = task.map((item) => {
+              if (customProp) {
+                if (customProp == item.prop) {
+                  return checkRule(item);
+                } else {
+                  return Promise.resolve(true);
+                }
+              } else {
+                return checkRule(item);
+              }
+            });
+            Promise.all(errors).then((errorRes) => {
+              errorRes = errorRes.filter((item) => item != true);
+              const res = { valid: true, errors: [] };
+              if (errorRes.length) {
+                res.valid = false;
+                res.errors = errorRes;
+              }
+              resolve(res);
+            });
+          } catch (error) {
+            reject(error);
+          }
         });
-      } catch (r) {
-        e(r);
-      }
-    });
-    return { validate: v, reset: g, submit: () => (v(), !1), formErrorTip: f };
-  }
-}), { create: M } = W("form"), R = M(
-  Z({
-    [C.name]: C
+      };
+      const submit = () => {
+        validate();
+        return false;
+      };
+      return { validate, reset, submit, formErrorTip };
+    }
+  };
+};
+const { create } = createComponent("form");
+const _sfc_main = create(
+  component({
+    [CellGroup.name]: CellGroup
   })
 );
-function ee(l, i, m, o, f, _) {
-  const g = D("nut-cell-group");
-  return H(), J("form", {
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_cell_group = resolveComponent("nut-cell-group");
+  return openBlock(), createElementBlock("form", {
     class: "nut-form",
     action: "#",
-    onSubmit: i[0] || (i[0] = K(() => !1, ["prevent"]))
+    onSubmit: _cache[0] || (_cache[0] = withModifiers(() => false, ["prevent"]))
   }, [
-    L(g, null, {
-      default: Q(() => [
-        X(l.$slots, "default")
+    createVNode(_component_nut_cell_group, null, {
+      default: withCtx(() => [
+        renderSlot(_ctx.$slots, "default")
       ]),
       _: 3
     })
   ], 32);
 }
-const ce = /* @__PURE__ */ Y(R, [["render", ee]]);
+const Form = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 export {
-  ce as default
+  Form as default
 };

package/dist/packages/_es/FormItem.js

@@ -1,13 +1,14 @@
-import { p as S } from "./pxCheck-38173291.js";
-import { inject as h, provide as _, computed as l, resolveComponent as A, openBlock as o, createBlock as w, normalizeClass as m, normalizeStyle as t, withCtx as $, createElementBlock as p, renderSlot as u, createTextVNode as v, toDisplayString as d, createCommentVNode as y, createElementVNode as f } from "vue";
-import { c as C } from "./component-234624bc.js";
-import c from "./Cell.js";
-import { _ as E } from "./_plugin-vue_export-helper-dad06003.js";
+import { p as pxCheck } from "./pxCheck-c6b9f6b7.js";
+import { inject, provide, computed, resolveComponent, openBlock, createBlock, normalizeClass, normalizeStyle, withCtx, createElementBlock, renderSlot, createTextVNode, toDisplayString, createCommentVNode, createElementVNode } from "vue";
+import { c as createComponent } from "./component-81a4c1d0.js";
+import Cell from "./Cell.js";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-cc2b3d55.js";
 import "../locale/lang";
-import "./index-50eed3d9.js";
+import "./index-54d03fc1.js";
 import "@nutui/icons-vue";
-const { componentName: I, create: k } = C("form-item"), B = k({
-  inheritAttrs: !1,
+const { componentName, create } = createComponent("form-item");
+const _sfc_main = create({
+  inheritAttrs: false,
   props: {
     prop: {
       type: String,
@@ -19,19 +20,21 @@ const { componentName: I, create: k } = C("form-item"), B = k({
     },
     rules: {
       type: Array,
-      default: () => []
+      default: () => {
+        return [];
+      }
     },
     required: {
       type: Boolean,
-      default: !1
+      default: false
     },
     showErrorMessage: {
       type: Boolean,
-      default: !0
+      default: true
     },
     showErrorLine: {
       type: Boolean,
-      default: !0
+      default: true
     },
     labelWidth: {
       type: [String, Number],
@@ -51,59 +54,69 @@ const { componentName: I, create: k } = C("form-item"), B = k({
     }
   },
   components: {
-    [c.name]: c
+    [Cell.name]: Cell
   },
   emits: [""],
-  setup(e, { emit: g, slots: n }) {
-    const s = h("formErrorTip");
-    _("form", {
-      props: e
+  setup(props, { emit, slots }) {
+    const parent = inject("formErrorTip");
+    provide("form", {
+      props
     });
-    const a = l(() => ({
-      width: S(e.labelWidth),
-      textAlign: e.labelAlign
-    })), i = l(() => ({
-      textAlign: e.bodyAlign
-    })), r = l(() => ({
-      textAlign: e.errorMessageAlign
-    }));
-    return { parent: s, labelStyle: a, bodyStyle: i, errorMessageStyle: r, getSlots: (b) => n[b] };
+    const labelStyle = computed(() => {
+      return {
+        width: pxCheck(props.labelWidth),
+        textAlign: props.labelAlign
+      };
+    });
+    const bodyStyle = computed(() => {
+      return {
+        textAlign: props.bodyAlign
+      };
+    });
+    const errorMessageStyle = computed(() => {
+      return {
+        textAlign: props.errorMessageAlign
+      };
+    });
+    const getSlots = (name) => slots[name];
+    return { parent, labelStyle, bodyStyle, errorMessageStyle, getSlots };
   }
-}), M = { class: "nut-cell__value nut-form-item__body" };
-function N(e, g, n, s, a, i) {
-  const r = A("nut-cell");
-  return o(), w(r, {
-    class: m(["nut-form-item", [{ error: e.parent[e.prop], line: e.showErrorLine }, e.$attrs.class]]),
-    style: t(e.$attrs.style)
+});
+const _hoisted_1 = { class: "nut-cell__value nut-form-item__body" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_nut_cell = resolveComponent("nut-cell");
+  return openBlock(), createBlock(_component_nut_cell, {
+    class: normalizeClass(["nut-form-item", [{ error: _ctx.parent[_ctx.prop], line: _ctx.showErrorLine }, _ctx.$attrs.class]]),
+    style: normalizeStyle(_ctx.$attrs.style)
   }, {
-    default: $(() => [
-      e.label || e.getSlots("label") ? (o(), p("view", {
+    default: withCtx(() => [
+      _ctx.label || _ctx.getSlots("label") ? (openBlock(), createElementBlock("view", {
         key: 0,
-        class: m(["nut-cell__title nut-form-item__label", { required: e.required }]),
-        style: t(e.labelStyle)
+        class: normalizeClass(["nut-cell__title nut-form-item__label", { required: _ctx.required }]),
+        style: normalizeStyle(_ctx.labelStyle)
       }, [
-        u(e.$slots, "label", {}, () => [
-          v(d(e.label), 1)
+        renderSlot(_ctx.$slots, "label", {}, () => [
+          createTextVNode(toDisplayString(_ctx.label), 1)
         ])
-      ], 6)) : y("", !0),
-      f("view", M, [
-        f("view", {
+      ], 6)) : createCommentVNode("", true),
+      createElementVNode("view", _hoisted_1, [
+        createElementVNode("view", {
           class: "nut-form-item__body__slots",
-          style: t(e.bodyStyle)
+          style: normalizeStyle(_ctx.bodyStyle)
         }, [
-          u(e.$slots, "default")
+          renderSlot(_ctx.$slots, "default")
         ], 4),
-        e.parent[e.prop] && e.showErrorMessage ? (o(), p("view", {
+        _ctx.parent[_ctx.prop] && _ctx.showErrorMessage ? (openBlock(), createElementBlock("view", {
           key: 0,
           class: "nut-form-item__body__tips",
-          style: t(e.errorMessageStyle)
-        }, d(e.parent[e.prop]), 5)) : y("", !0)
+          style: normalizeStyle(_ctx.errorMessageStyle)
+        }, toDisplayString(_ctx.parent[_ctx.prop]), 5)) : createCommentVNode("", true)
       ])
     ]),
     _: 3
   }, 8, ["class", "style"]);
 }
-const G = /* @__PURE__ */ E(B, [["render", N]]);
+const FormItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 export {
-  G as default
+  FormItem as default
 };

package/dist/packages/_es/Grid.js

@@ -1,9 +1,10 @@
-import { c as o } from "./component-234624bc.js";
+import { c as createComponent } from "./component-81a4c1d0.js";
 import "vue";
-import { c as t } from "./common-d218746f.js";
+import { c as component } from "./common-b9a5e726.js";
 import "../locale/lang";
-import "./pxCheck-38173291.js";
-const { create: r } = o("grid"), i = r(t);
+import "./pxCheck-c6b9f6b7.js";
+const { create } = createComponent("grid");
+const _sfc_main = create(component);
 export {
-  i as default
+  _sfc_main as default
 };

package/dist/packages/_es/GridItem.js

@@ -1,27 +1,30 @@
-import { inject as k, getCurrentInstance as y, onUnmounted as x, computed as a, ref as h, openBlock as u, createElementBlock as d, normalizeClass as m, normalizeStyle as S, createElementVNode as p, renderSlot as f, Fragment as v, createTextVNode as b, toDisplayString as N } from "vue";
-import { u as _ } from "./index-50eed3d9.js";
-import { c as B } from "./component-234624bc.js";
-import { p as $ } from "./pxCheck-38173291.js";
-import { G as j } from "./common-d218746f.js";
-import { _ as q } from "./_plugin-vue_export-helper-dad06003.js";
+import { inject, getCurrentInstance, onUnmounted, computed, ref, openBlock, createElementBlock, normalizeClass, normalizeStyle, createElementVNode, renderSlot, Fragment, createTextVNode, toDisplayString } from "vue";
+import { u as useRouter } from "./index-54d03fc1.js";
+import { c as createComponent } from "./component-81a4c1d0.js";
+import { p as pxCheck } from "./pxCheck-c6b9f6b7.js";
+import { G as GRID_KEY } from "./common-b9a5e726.js";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-cc2b3d55.js";
 import "../locale/lang";
-function w(e) {
-  const n = k(e, null);
-  if (n) {
-    const o = y(), { add: s, remove: t, internalChildren: i } = n;
-    s(o), x(() => t(o));
-    const l = a(() => i.indexOf(o));
+function useInject(key) {
+  const parent = inject(key, null);
+  if (parent) {
+    const instance = getCurrentInstance();
+    const { add, remove, internalChildren } = parent;
+    add(instance);
+    onUnmounted(() => remove(instance));
+    const index2 = computed(() => internalChildren.indexOf(instance));
     return {
-      parent: n,
-      index: l
+      parent,
+      index: index2
     };
   }
   return {
     parent: null,
-    index: h(-1)
+    index: ref(-1)
   };
 }
-const { create: E, componentName: C } = B("grid-item"), I = E({
+const { create, componentName } = createComponent("grid-item");
+const _sfc_main = create({
   props: {
     text: {
       type: String
@@ -36,63 +39,86 @@ const { create: E, componentName: C } = B("grid-item"), I = E({
     },
     replace: {
       type: Boolean,
-      default: !1
+      default: false
     }
   },
   emits: ["click"],
-  setup(e, { emit: n }) {
-    const o = w(j);
-    if (!o.parent)
+  setup(props, { emit }) {
+    const Parent = useInject(GRID_KEY);
+    if (!Parent.parent)
       return {};
-    const s = o.index, t = o.parent.props, i = a(() => ({
-      [C]: !0
-    })), l = a(() => {
-      const r = {
-        flexBasis: `${100 / +t.columnNum}%`
+    const index2 = Parent.index;
+    const parent = Parent.parent.props;
+    const rootClass = computed(() => {
+      const prefixCls = componentName;
+      return {
+        [prefixCls]: true
+      };
+    });
+    const rootStyle = computed(() => {
+      const style = {
+        flexBasis: `${100 / +parent.columnNum}%`
       };
-      return t.square ? r.paddingTop = `${100 / +t.columnNum}%` : t.gutter && (r.paddingRight = $(t.gutter), s.value >= t.columnNum && (r.marginTop = $(t.gutter))), r;
-    }), g = a(() => {
-      const r = `${C}__content`;
+      if (parent.square) {
+        style.paddingTop = `${100 / +parent.columnNum}%`;
+      } else if (parent.gutter) {
+        style.paddingRight = pxCheck(parent.gutter);
+        if (index2.value >= parent.columnNum) {
+          style.marginTop = pxCheck(parent.gutter);
+        }
+      }
+      return style;
+    });
+    const contentClass = computed(() => {
+      const prefixCls = `${componentName}__content`;
       return {
-        [`${r}`]: !0,
-        [`${r}--border`]: t.border,
-        [`${r}--surround`]: t.border && t.gutter,
-        [`${r}--center`]: t.center,
-        [`${r}--square`]: t.square,
-        [`${r}--reverse`]: t.reverse,
-        [`${r}--${t.direction}`]: !!t.direction,
-        [`${r}--clickable`]: t.clickable || e.to || e.url
+        [`${prefixCls}`]: true,
+        [`${prefixCls}--border`]: parent.border,
+        [`${prefixCls}--surround`]: parent.border && parent.gutter,
+        [`${prefixCls}--center`]: parent.center,
+        [`${prefixCls}--square`]: parent.square,
+        [`${prefixCls}--reverse`]: parent.reverse,
+        [`${prefixCls}--${parent.direction}`]: !!parent.direction,
+        [`${prefixCls}--clickable`]: parent.clickable || props.to || props.url
       };
-    }), c = _();
-    return {
-      rootClass: i,
-      rootStyle: l,
-      contentClass: g,
-      handleClick: (r) => {
-        n("click", r), e.to && c ? c[e.replace ? "replace" : "push"](e.to) : e.url && (e.replace ? location.replace(e.url) : location.href = e.url);
+    });
+    const router = useRouter();
+    const handleClick = (event) => {
+      emit("click", event);
+      if (props.to && router) {
+        router[props.replace ? "replace" : "push"](props.to);
+      } else if (props.url) {
+        props.replace ? location.replace(props.url) : location.href = props.url;
       }
     };
+    return {
+      rootClass,
+      rootStyle,
+      contentClass,
+      handleClick
+    };
   }
-}), R = { class: "nut-grid-item__text" };
-function T(e, n, o, s, t, i) {
-  return u(), d("view", {
-    class: m(e.rootClass),
-    style: S(e.rootStyle),
-    onClick: n[0] || (n[0] = (...l) => e.handleClick && e.handleClick(...l))
+});
+const _hoisted_1 = { class: "nut-grid-item__text" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("view", {
+    class: normalizeClass(_ctx.rootClass),
+    style: normalizeStyle(_ctx.rootStyle),
+    onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
   }, [
-    p("view", {
-      class: m(e.contentClass)
+    createElementVNode("view", {
+      class: normalizeClass(_ctx.contentClass)
     }, [
-      f(e.$slots, "default"),
-      p("view", R, [
-        e.text ? (u(), d(v, { key: 0 }, [
-          b(N(e.text), 1)
-        ], 64)) : f(e.$slots, "text", { key: 1 })
+      renderSlot(_ctx.$slots, "default"),
+      createElementVNode("view", _hoisted_1, [
+        _ctx.text ? (openBlock(), createElementBlock(Fragment, { key: 0 }, [
+          createTextVNode(toDisplayString(_ctx.text), 1)
+        ], 64)) : renderSlot(_ctx.$slots, "text", { key: 1 })
       ])
     ], 2)
   ], 6);
 }
-const U = /* @__PURE__ */ q(I, [["render", T]]);
+const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 export {
-  U as default
+  index as default
 };